c++ - 继承 - 运算符重载

Question

我有两个类，基类和派生类。在主要我有一个 vector 是 *base类型并包含一个基础对象和一个派生对象。我已经为两个类重载了输出运算符，但是当我打印派生类的 vector 时，虽然我已经单独重载了它，但会调用基本输出运算符。我应该在我的程序中改变什么来改变输出:

12
30

到

12
30 31

?

这是代码:

#include <iostream>
#include <vector>

using namespace std;
class base {
    int x;
public:
    base(int _x) : x(_x) {}
    friend ostream& operator<<(ostream& out, base obj) {
            return out << obj.x;
    }
};

class derived : public base {
    int y;
public:
    derived(int _x, int _y) : base(_x), y(_y) {}
    friend ostream& operator<<(ostream& out, derived obj) {
            return out << (base) obj << ' ' << obj.y;
    }
};

int main() {
        vector<base*> vec;
        base* a = new base(12);
        derived* b = new derived(30,31);
        vec.push_back(a);
        vec.push_back(b);
        for (auto p: vec) cout << *p << '\n';
}

Answer 1

基于底层对象的动态调度仅适用于 virtual成员函数。它不适用于非成员函数或非 virtual成员函数。

解决问题的一种方法是:

使用 friend函数使用基本类型。

更改 obj 的参数类型成为 const引用。

从该函数中，调用 virtual成员函数来做真正的工作。

class base {
    int x;
public:
    base(int _x) : x(_x) {}

    virtual std::ostream& write(std::ostream& out) const
    {
       return (out << x);
    }

    // Change obj to be a const reference
    friend std::ostream& operator<<(std::ostream& out, base const& obj)
    {
        return obj.write(out);
    }
};

class derived : public base {
    int y;
public:
    derived(int _x, int _y) : base(_x), y(_y) {}

    virtual std::ostream& write(std::ostream& out) const
    {
       // Let the base class take care of its part.
       base::write(out);

       // Now take care of this class part.
       return ( out << ' ' << y);
    }

    // This is useless now.
    // friend ostream& operator<<(ostream& out, derived obj) {
    //         return out << (base) obj << ' ' << obj.y;
    // }
};

PS Why is "using namespace std;" considered bad practice?