1

为任何糟糕的措辞道歉，我不太确定如何表达这个问题。

我有一个基类 A，它有一个纯虚拟运算符+=，它接受一个自身的实例。在派生类 B 中，我想覆盖基类的 operator+= 以便它采用 B 的实例（而不是 A）。

// Abstract base class
template <class T>
class A
{
    A() = default;

    virtual A<T>& operator+=(const A&) = 0;
}

// Derived class
template <class T>
class B : public A<T>
{
   T some_field = 3.14159;

   B(const T x) : A(), some_field(x) {}

   B<T>& operator+=(const B& b) override
   {
       this.some_field += b.some_field;

       return (*this);
   }
}

我明白为什么这不起作用；这两种方法是不同的函数，因为它们需要不同的参数。但是，我假设必须有某种方法来保证从 A 派生的任何类都将实现 operator+= ，其中它将派生类的实例作为参数。

virtual operator+=(const <this_class_type>&) = 0;

请问你能提供一个解决方案吗？非常感谢！

4

1 回答 1

3

实现此目的的一种方法是使用T参数：

template<typename T>
class IBase
{
public:
    virtual IBase& operator+=(const T& Instance) = 0;
};

class CDerived : IBase<CDerived>
{
public:
    IBase& operator+=(const CDerived&) override
    {
        return *this;
    }
};

class COtherDerived : IBase<COtherDerived>
{
public:
    IBase& operator+=(const COtherDerived&) override
    {
        return *this;
    }    
};

int main(int argc, char** argv)
{
    CDerived Derived1, Derived2;
    Derived1 += Derived2;
    COtherDerived Derived3;
    // Derived3 += Derived1; <-- Will not compile
}
于 2018-03-21T12:29:34.443 回答