如何避免忘记在子类中定义operator ==？

Question

我有一个基类,并在其上定义一个运算符==.并且B是的一个子类A,我忘记定义operator==上B.然后A::operator==用于比较B,通常这会产生意想不到的结果.有什么好方法可以避免这种"忘记"吗？我添加一个例子来澄清我的问题.

class A
{
public:
    bool operator==(const A& rhs) const
    {
        return i == rhs.i;
    }

    int i
};

class B : public A
{
public:
    int j;
}

B b1, b2;
b1.i = 1; b1.j = 2;
b2.i = 1; b1.j = 3;
bool b = (b1 == b2); // will be true

Answer 1

您可以尝试的是放入A命名空间,在该命名空间中创建operator ==非成员模板,让ADL处理它.

#include <iostream>

namespace stuff {
class A
{
};

class B : public A {};

template <typename T>
bool operator == (const T &lhs, const T &rhs)
{
  std::cout << __PRETTY_FUNCTION__ << '\n';
  return &lhs == &rhs; // <-- replace this with something real
}

}

struct C {};

int main()
{
  stuff::A a, aa;
  stuff::B b, bb;
  C c, cc;

  b == bb;
  aa == a;

  aa == cc; // error: no match for "operator==" stuff::A and C
  b == a;   // error: no match for "operator==" stuff::B and stuff::A
}

编辑:对于您想要进行等式检查的编辑示例,将类的每个部分与其他相应的相应部分进行比较,DyP的建议可以起作用.例如:

// same as before
// ...
class A
{
public:
  bool is_equal(const A &rhs) const { return i == rhs.i; }
};

class B : public A
{
public:
  bool is_equal(const B &rhs) const { return A::is_equal(rhs) && (j == rhs.j); }
};

template <typename T>
bool operator == (const T &lhs, const T &rhs)
{
  std::cout << __PRETTY_FUNCTION__ << '\n';
  return lhs.is_equal(rhs);
}

现在再次在使用代码中进行比较:

// ...
b.i = 1, bb.i = 1;
b.j = 1, bb.j = 42;
cout << boolalpha << (b == bb) << '\n';
b.j = 42;
cout << (b == bb) << '\n';

a.i = 2, aa.i = 3;
cout << (aa == a) << '\n';    

输出:

bool stuff::operator==(const T&, const T&) [with T = stuff::B]
false
bool stuff::operator==(const T&, const T&) [with T = stuff::B]
true
bool stuff::operator==(const T&, const T&) [with T = stuff::A]
false

Answer 2

允许Greatwolf的伟大方法进行隐式转换有点棘手：

#include <type_traits>

namespace stuff
{

    template<class T, class U>
    bool operator== (const T &lhs, const U &rhs)
    {
        using namespace std;
        static_assert(is_convertible<T, U>{} || is_convertible<U, T>{},
                      "invalid argument type");
        static_assert
        (
               is_same<T, U>{}
            || ( not is_base_of<T, U>{} && not is_base_of<U, T>{})
            , "use explicit casts to compare derived to base class types"
        );
        return is_equal(lhs, rhs);
    }

    template<class T>
    bool is_equal(T const&, T const&)
    {
        // force compile-time failure when instantiating
        static_assert(std::is_same<T, void>{},
          "no free is_equal function for these argument types available");

        return false;
    }

    class A
    {
    private:
        int i;

        friend bool is_equal(A const& lhs, A const& rhs)
        { return lhs.i == rhs.i; }

    public:
        A(int p_i) : i(p_i) {}
    };

    class B : public A
    {
        int j;

    public:
        B(int p_i, int p_j) : A(p_i), j(p_j) {}
    };

    class C : public A
    {
    private:
        int j;

        friend bool is_equal(C const& lhs, C const& rhs)
        {
            return    is_equal(static_cast<A const&>(rhs),
                               static_cast<A const&>(lhs))
                   && lhs.j == rhs.j;
        }

    public:
        C(int p_i, int p_j) : A(p_i), j(p_j) {}
    };

}

struct D
{
    operator stuff::C() const
    {
        return stuff::C(1, 42);
    }
};

#include <iostream>
int main()
{
    stuff::A a(1), aa(1);
    stuff::B b(1, 42), bb(1, 42);
    stuff::C c(1, 42), cc(1, 42);

    D d;

    // commented lines invoke compilation failures
    std::cout << "a == aa: " << (a == aa) << std::endl;
  //std::cout << "a == b : " << (a == b ) << std::endl;
  //std::cout << "b == bb: " << (b == bb) << std::endl;
  //std::cout << "a == c : " << (a == c ) << std::endl;
    std::cout << "c == cc: " << (c == cc) << std::endl;
    std::cout << "d == c : " << (d == c ) << std::endl;
}