0

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

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

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

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

4

3 回答 3

5

如果您可以确定Derived1并且Derived2是叶子类（即没有其他类可以从它们派生），您可以使用奇怪的重复模板模式来做到这一点：

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

在编译时没有办法阻止这种情况。而且即使你想允许它，在没有多次 dispatch的情况下也不容易为这个操作获得体面的语义。

于 2012-10-05T09:00:17.427 回答
1

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

#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...
}
于 2012-10-05T09:28:04.140 回答
-3

只要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 ba:-1 ab:-1 cc:4 ac:-1 bc:-1 abc:1

我看到的唯一问题是，当将多个操作链接在一起时，铸造搞砸了处理。在这里，a+b+c432 的评估结果是(a+b)+c该a+b位经历了错误条件（返回 -1），但被转换为Base让(-1)+c返回“1”的 a。

于 2012-10-05T09:02:18.933 回答