Question

我正在尝试编写一个uint128_t库（http://stackoverflow.com/questions/6119306/operator-overloading-c-placement）并且遇到了一个问题：我需要对不同类型的整数进行操作，例如{ {1}}。我编写了运算符重载，例如uint128_t ^ uint64_t。我还需要能够做template <typename t> uint128_t operator^(T val)。但是，因为我的uint128_t使用2 uint64_t来存储值，所以我不能简单地使用uint128_t作为T.因此，我编写了2个不同的函数，一个用T作为参数类型，另一个用uint128_t作为类型。

问题是编译器对标准c ++ int类型和uint128_t使用uint128_t ^ uint128_t版本。我如何让编译器区分它们？

编辑：我在链接中的类中有这个代码：

T val

如果我这样做

template <typename T>
bool operator==(T val){
    return (LOWER == (uint64_t) val);
}

bool operator==(uint128_t val){
    return ((UPPER == val.upper()) && (LOWER == val.lower()));
}

这两行都会使用top运算符。但是，由于uint128_t是2个部分，并且是一个对象，因此计算机将uint64_t与类进行比较，而不是将值进行比较。我如何强制计算机使用第二个==运算符？

Answer 1

除了转换构造函数之外，您甚至不需要额外的重载。然后你只需编写处理uint128_t的运算符，如果你试图传递另一个可转换类型，比如int，它将使用转换构造函数转换，然后调用相应的运算符。

看，这有效：

#include <cstdint>
#include <iostream>

class uint128_t{
    private:
        uint64_t UPPER, LOWER;

    public:
    // constructors
        uint128_t(){
            UPPER = 0;
            LOWER = 0;
        }

        template <typename T>
        uint128_t(T val){
            UPPER = 0;
            LOWER = (uint64_t) val;
        }

        template <typename S, typename T>
        uint128_t(const S & upper_val, const T & lower_val){
            UPPER = (uint64_t) upper_val;
            LOWER = (uint64_t) lower_val;
        }       

        uint64_t upper() const{
            return UPPER;
        }

        uint64_t lower() const{
            return LOWER;
        }

        uint128_t & operator+=(const uint128_t & rhs)
        {
            uint64_t old_lower = LOWER;
            LOWER += rhs.LOWER;
            if(LOWER < old_lower)
                ++UPPER;
            UPPER += rhs.UPPER;
            return *this;
        }
};

bool operator==(const uint128_t & lhs, const uint128_t & rhs){
    return ((lhs.upper() == rhs.upper()) && (lhs.lower() == rhs.lower()));
}

int main()
{
    uint128_t v(25);
    v += 25;
    int c = 50;
    if(v == c)
        std::cout << "Good";
    if(v == c + 1)
        std::cout << "Bad";
}

http://ideone.com/BEq03

Answer 2

尝试将模板运算符从类中取出并使其成为全局，然后指定所需的特定转换，即：

template<typename T>
bool operator==(uint128_t v1, T v2)
{
    return (v1.lower() == (uint64_t) v2);
}

template<>
bool operator==(uint128_t v1, uint128_t v2)
{
    return ((v1.upper() == v2.upper()) && (v1.lower() == v2.lower()));
}

使用模板时选择正确的相等运算符

2 个答案: