c++:继承具有不同(但协变)返回类型的方法

Question

假设我们有两个类:

class DataStructure {
public:
    DataStructure &operator=(const DataStructure &);
    friend const DataStructure &operator+(int, const DataStructure &);
    //...
};
class Array : public DataStructure {
public:
    Array &operator=(const DataStructure &);
    friend const Array &operator+(int, const Array &);
    //...
};

，我们希望Array::operator=和Array的朋友operator+与DataStructure::operator=和DataStructure的朋友operator+做同样的事情，除了它们应该返回Array &, const Array &而不是DataStructure &, const DataStructure &。我需要用几十种方法来实现它，所以有没有比下面更简单的方法来实现它?

Array &Array::operator=(const DataStructure &other) {
    return (Array &)DataStructure::operator=(other);
}
const Array &operator+(int x, const Array &other) {
    return (const Array &)(x + (DataStructure)other);
}

---

编辑:我想到了另一个主意，虽然这是一个相当糟糕的主意:

class Array;
class DataStructure {
public:
    //...
    operator Array &() const;
};
//...
DataStructure::operator Array &() const {
    return (Array &)*this;
}

这样，只要需要，DataStructure就隐式地转换为Array，尽管它仍然不能正确处理DataStructure和Array都是合法的，但做不同的事情，如以下示例:

//in class DataStructure:
public:
friend ostream &operator<<(ostream &os,const DataStructure &)
    { os << "DataStructure" << endl; return os;}
//in class Array:
public:
friend ostream &operator<<(ostream &os,const Array &)
    { os << "Array" << endl; return os;}
//...
int main() {
    Array x;
    cout << 1 + x << endl;
    // output: "DataStructure" instead of "Array"
    return 0;
}

谢谢你!

Answer 1

你的实现不是很好:operator=应该返回对数组类型对象的引用，而不应该是虚拟的:

Array &Array::operator=(const DataStructure &other) {
    DataStructure::operator=(other);
    return *this;
}

你可以改变DataStructure使用NVI:

#include <iostream>
class DataStructure {
    public:
        DataStructure(){}
        inline virtual ~DataStructure(){}
        DataStructure &operator=(const DataStructure & other);
        inline friend const DataStructure &operator+(const int a, const DataStructure & other)
        { other.add(a); return other; }
        //...
    private:
        virtual void add( const int a ) const = 0;
    };
struct Array : DataStructure
{
    virtual void add( const int a ) const
    {
        std::cout<<"adding "<<a<<std::endl;
    }
};
void foo(const DataStructure &a)
{
    const DataStructure &b = 5 + a;
}
int main()
{
    Array a;
    foo(a);
}

检查现场演示。然后你必须在你的派生类Array中实现add方法。

---

致你的编辑:

你的新想法是用c++做事情的糟糕方式。你要做的就是告诉你的编译器:"别抱怨了，我知道我在做什么。"此外，它还会导致未定义的行为。它可能看起来可以工作，直到有一天你的应用程序开始崩溃。

Answer 2

我终于找到了答案。对于operator=:

class Array : public DataStructure {
public:
    //...
    using DataStructure::operator=;
    Array &operator=(const DataStructure &);
};

只写Array &operator=(const DataStructure &);会隐藏DataStructure::operator=，但using语句只改变方法的返回类型。

注意: using语句必须在Array &operator=(const DataStructure &);行之前，否则operator=会有歧义。

---

对于operator+，我发现唯一的解决方案是非常有问题的。它使用模板:

public DataStructure {
public:
    template<class T> friend const T &operator+(int, const T &);
};

例如，如果最初的实现是

const DataStructure &operator+(int x, const DataStructure &other) {
    DataStructure addition(other); /* in this example we assume
    *   that "DataStructure" isn't abstract */
    addition.someParameter += x; /* for simplicity, assume that
    *   "someParameter" is public/protected */
    return addition;
}

，我们希望得到与

相同的结果

const Array &operator+(int x, const Array &other) {
    return (const Array &)(x + (DataStructure)other);
}

我们可以简单地写:

template<class T>
const T &operator+(int x, const T &other) {
    DataStructure addition(other); /* notice that usually we would want
    *   to write "T" instead of "DataStructure", but sometimes it would
    *   give a different result */
    addition.someParameter += x;
    return (const T &)addition;
}

但是，如果存在与DataStructure或Array无关的函数operator+(int,/*const*/ ThirdClass /*&*/)，则必须更改它，这可能会使代码混乱。幸运的是，通常只有几个友元函数，因此实现一个执行转换的新方法(如问题所示)并不是那么糟糕。