Operator==() 模板类的隐式转换

Question

I have a templated class like so:

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;
};

This works fine, however I'd like to extend this operator==() method to allow the equality to only be valid if the object passed in is of the same templated type. Here's an example:

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

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

When I do this:

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

I notice that the instance of the class passed in is implicitly converted into the type of this class. I thought about including a member variable on the templated object to distinguish them, but it's a little annoying to have to add an extra variable it feels like I shouldn't need. Is there a better way of achieving this equality test?

Answer 1

As I understand, there exists implicit conversion from Foo<T1> to Foo<T2> .

Possible solutions are:

1. Forbid implicit type conversion (use explicit keyword for constructors and cast operators).

2. Make operator == templated and use enable_if to allow only possible combinations:

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