派生重载运算符，但仅对相同类型进行操作

Question

假设我有一个基类和两个派生自它的类：

class Base
{
protected:
    double value;
public:
    virtual ~Base();

    Base(double value) : value(value) {}
    Base(const Base& B) { value=B.value; }

    Base operator+ (const Base& B) const { 
        return Base(value+B.value); 
    }

};

class final Derived1 : public Base {
public:
    Derived1(double value) : Base(value) {}
};

class final Derived2 : public Base {
public:
    Derived2(double value) : Base(value) {}
};

我要完成以下工作：

int main(int argc, char *argv[])
{
    Derived1 a = Derived1(4.0);
    Derived2 b = Derived2(3.0);

    a+a; // this should return a Derived1 object
    b+b; // this should return a Derived2 object

    a+b; // this should FAIL AT COMPILE TIME

    return 0;
}

换句话说，我想保证继承的operator+ 只对调用实例同类型的对象进行操作。

我如何干净地做到这一点？我发现自己为每个类重新定义了运算符：

class final Derived1 : public Base {
    ...
    Derived1 operator+ (const Derived1& D1) const {
        return Derived1(value+D1.value);
    }
    ...
};

class final Derived2 : public Base {
    ...            
    Derived2 operator+ (const Derived2& D1) const {
        return Derived2(value+D1.value);
    }
    ...
};

但这只是一种痛苦。此外，对我来说，重用代码似乎并不合适。

在这里使用的正确技术是什么？

Answer 1

如果您可以确保 Derived1 和 Derived2 是叶类（即没有其他类可以从它们派生），您可以使用 curiously recurring template pattern 做到这一点：

template <typename T>
class BaseWithAddition : public Base {
    T operator+(T const& rhs) const {
        return T(value + rhs.value);
    }
};

class final Derived1 : public BaseWithAddition<Derived1> {
    // blah blah
};

class final Derived2 : public BaseWithAddition<Derived2> {
    // blah blah
};

（final 是 C++11 的一项功能，可防止进一步推导。）

如果您允许从 Derived1 和 Derived2 派生，那么您会遇到麻烦：

class Derived3 : public Derived1 {};
Derived3 d3;
Derived1 d1;
Derived1& d3_disguised = d3;
d1 + d3_disguised; // oooops, this is allowed

在编译时没有办法防止这种情况发生。即使你想允许它，如果没有multiple dispatch，这个操作也不容易获得体面的语义。

Answer 2

只要value 仅在基类中定义，并且操作不需要访问任何派生成员，您就可以只定义基运算符并让隐式类型转换处理休息。对于不同类型的错误，使用基于枚举的系统来跟踪类型，然后做一个简单的比较来检查无效条件可能是值得的。

enum eTypeEnum {BASE, DER1, DER2};

class Base {
public:
  virtual ~Base(){}

  Base(double value) : eType(BASE),value(value) {}
  Base(const Base& B) { value=B.value; }

  Base operator+ (const Base& B) const {
    if (eType != B.eType) return -1; //error condition
    return Base(value+B.value);
  }
  double getVal(){return value;}
protected:
  eTypeEnum eType;
  double value;
};

class Derived1 : public Base {
public:
  Derived1(double value) : Base(value) {eType = DER1;}
};

class Derived2 : public Base {
public:
  Derived2(double value) : Base(value) {eType = DER2;}
};


int main() {
  int tmp;
  Derived1 a(4.0);
  Derived2 b(3.0);
  Base c(2.0);

  cout << "aa:" << (a+a).getVal();     // 8
  cout << "\nbb:" << (b+b).getVal();   // 6
  cout << "\nba:" << (b+a).getVal();   // 7
  cout << "\nab:"<< (a+b).getVal();    // 7

  cout << "\ncc:"<< (c+c).getVal();    // 4
  cout << "\nac:"<< (a+c).getVal();    // 6
  cout << "\nbc:" << (b+c).getVal();   // 5
  cout << "\nabc:" << (a+b+c).getVal();// 9
  cout << endl;
  cin >> tmp;
  return 0;
}

输出： AA:8 BB:6 巴：-1 ab:-1 抄送：4 交流：-1 公元前：-1 abc:1

我看到的唯一问题是，当将多个操作链接在一起时，强制转换会搞砸处理。在这里，a+b+c 432 的计算结果为 (a+b)+c，因此 a+b 位遇到错误情况（返回 -1），但被转换为 Base，这让 (-1)+c 返回“1”。

Answer 3

您可以使用专门的模板函数来添加值。不幸的是，这个技巧不适用于运营商： 如果类型不同则失败，并返回正确的类型：

#include <type_traits>
class Base;
template <class Derived>
Derived add(const Derived& l, const Derived& r, 
            typename std::enable_if<std::is_base_of<Base,Derived>::value>::type* = NULL);


class Base
{
 ...
    template <class Derived>
    friend Derived add(const Derived& l, const Derived& r, 
       typename std::enable_if<std::is_base_of<Base,Derived>::value>::type* = NULL);
};

template <class Derived>
Derived add(const Derived& l, const Derived& r, 
 typename std::enable_if<std::is_base_of<Base,Derived>::value>::type* = NULL) 
{ 
    return l.value + r.value; 
}

它的工作证明：

int main() {
   int a = 0;
   a = a + a;
   Derived1 d11(0), d12(0);
   Derived2 d21(0), d22(0);
   add(d11, d12);
   add(d21, d22);
   add(d12, d22); // here it fails to compile...
}