运算符==() 的模板化 Class 的隐式转换

Question

我有一个模板化的 class 像这样：

struct Base
{
    bool operator==(const Base& other) const {
        return v == other.v;
    }
    int v;
};
struct Abc : public Base
{
    void execute() { /*logic1*/ }
};

struct Def : public Base
{
    void execute() { /*logic2*/ }
};

template <typename T>
class Foo
{
public:
    bool operator==(const Foo& other) const {
        return (a == other.a) && (b == other.b);
    }

    int a;
    T b;
};

这很好用，但是我想扩展这个 operator==() 方法，让等式只有在传入的对象是相同的模板类型时才有效。这是一个例子：

Foo<Abc> obj1;
Foo<Abc> obj2;
Foo<Def> obj3;

obj1 == obj2; // should be true
obj1 == obj3; // should fail at compile-time or run-time

当我这样做时：

bool operator==(const Foo& other) const {
    std::cerr << typeid(other).name() << std::endl;
    return (a == other.a) && (b == other.b);
}

我注意到传入的 class 的实例被隐式转换为这个 class 的类型。我考虑过在模板化对象上包含一个成员变量来区分它们，但是不得不添加一个我觉得不需要的额外变量有点烦人。有没有更好的方法来实现这个平等测试？

Answer 1

据我了解，存在从 Foo<T1> 到 Foo<T2> 的隐式转换。

可能的解决方案是：

禁止隐式类型转换（对构造函数和转换运算符使用 explicit 关键字）。

使 operator == 模板化并使用 enable_if 只允许可能的组合：

template <typename T1, typename = std::enable_if<std::is_same<T, T2>::value>::type>
bool operator == (const Foo<T1>& other) const

运算符==() 的模板化 Class 的隐式转换

Implicit Conversion of Templated Class for Operator==()

c++

templates

implicit-conversion

operator-keyword