c++ - 对模板类中 operator+ 重载值的限制

Question

我正在使用模板进行一些练习，但我遇到了这个问题。我有一个类，它表示具有基础类型和指定编译时起始值的计数器。我想支持计数器类型之间以及具有正确类型的整数类型之间的算术运算符。例如，我想在编译时拒绝一个带有 uint8_t 的计数器的总和。作为具有 int 类型变量的基础类型.到现在为止还挺好。

我得到的是，即使是应该正确的操作也无法编译。这里主要部分显示问题。

#include <iostream>
#include <type_traits>
#include <limits>


template <typename Source, typename Dest, std::enable_if_t<std::is_integral<Source>::value && std::is_integral<Dest>::value, int> =0>
struct type_not_narrow{
    static constexpr bool value= std::numeric_limits<Source>::max() <= std::numeric_limits<Dest>::max();
};

template<typename T, T N, std::enable_if_t<std::is_integral<T>::value, int> =0>
class basic_counter{
    T cnt;
    basic_counter(T initializer): cnt(initializer){}
public:

    basic_counter(): cnt(N){};
    template <typename T1, T1 N1, typename T2, T2 N2>
    friend basic_counter<typename std::common_type<T1,T2>::type, N1+N2> operator+(const basic_counter<T1, N1>& lhs,
                                                                              const basic_counter<T2, N2>& rhs);

    template <typename X, typename U, U M, std::enable_if_t<type_not_narrow<X, U>::value, int>>
    friend basic_counter<U,M> operator+(const basic_counter<U, M> lhs, const X step);

    operator T() const{
        return cnt;
    }
};
template <typename T1, T1 N1, typename T2, T2 N2>
basic_counter<typename std::common_type<T1,T2>::type, N1+N2> operator+(const basic_counter<T1, N1>& lhs,
                                                                       const basic_counter<T2, N2>& rhs){
    return {lhs.cnt+rhs.cnt};
}
template<typename X, typename T, T N, std::enable_if_t<type_not_narrow<X, T>::value, int> =0>
basic_counter<T,N> operator+(const basic_counter<T, N> lhs, const X step){
    basic_counter<T,N> c=lhs;
    c.cnt+=step;
    return c;
}


int main() {


    basic_counter<unsigned long int, 1> c1;
    basic_counter<unsigned long int, 2> c2;
    basic_counter<unsigned long int, 3> c3=c2+c1;
    unsigned long int ul=5;
    int i=5;
    char ch=5;
    basic_counter<unsigned long int, 2> c4=c2+5;
    basic_counter<unsigned long int, 2> c5=c2+i;
    basic_counter<unsigned long int, 2> c5bis=c2+ch;
    basic_counter<unsigned long int, 2> c6=c2+ul;


    //should not compile due to narrowing (and it's correct)
    //basic_counter<unsigned long int, 2> c7=c2+5.2;
    //basic_counter<uint8_t,0> c8;
    //c8=c8+i;

    basic_counter<uint8_t,0> c9;
    //this should compile
    c9=c9+1;
    //this should not
    c9=c9+2000;

    return 0;
}

对于最后一行，如果整数操作数可以成功转换为不窄的类型，我希望它能够编译。例如加 1 应该编译，而加 2000 不应该编译，因为 1 可以用 uint8_t 表示。而2000不能。

Answer 1

如果您更正评论中提到的未定义行为，则此表达式:

    c9=c9+1;

编译失败，因为 1 是 int文字。编译器为此抛出了一些奇怪的错误，因为它试图通过调用隐式强制转换运算符来转换 c9 来使整个事情工作。为整数，并调用私有(private)值构造函数。

所以这条线会起作用:

    basic_counter<uint8_t,0> c10=c9+uint8_t(1);

这是一个尴尬的妥协，因为仍然不可能将函数参数的值用于模板参数和静态断言(除非 P1045R1 被采用)。