使用引用此对象的基类指针向量打印派生类对象

Question

如何制作这个指针向量，然后正确打印 de Derived1 对象和 Derived2 对象？

即使我在派生类中包含"<<"运算符，似乎也使用了基类运算符。而且我不能使操作员成为虚拟的，因为他们不是类的成员，他们是朋友。

我该怎么做才能使程序从 Derived1 类或 Derived2 类中获取"<<"运算符，此外，通过使用打印基类的东西：

out << (Base&)temp;

在我的运营商的定义中.

#include<iostream>
#include<fstream>
using namespace std;
class Base {
private:
    int base;
public:
    Base() :base(10){}
    friend ostream& operator<<(ostream& out, const Base& temp)
    {
        out << "======== BASE ========" << endl;
        out << temp.base << endl;
        out << "======== BASE ========" << endl;
        return out;
    }
    friend ofstream& operator<<(ofstream& out, const Base& temp)
    {
        out << "======== BASE ========" << endl;
        out << temp.base << endl;
        out << "======== BASE ========" << endl;
        return out;
    }
};
class Derived1 :public Base {
private :
    int derived1;
public:
    Derived1() :derived1(5){}
        friend ostream& operator<<(ostream& out, const Derived1& temp)
    {
        out << (Base&)temp;
        out << "======== DERIVED1 ========" << endl;
        out << temp.derived1 << endl;
        out << "======== DERIVED1 ========" << endl;
        return out;
    }
    friend ofstream& operator<<(ofstream& out, const Derived1& temp)
    {
        out << (Base&)temp;
        out << "======== DERIVED1 ========" << endl;
        out << temp.derived1 << endl;
        out << "======== DERIVED1 ========" << endl;
        return out;
    }
};
class Derived2 :public Base {
private:
    int derived2;
 public:
    Derived2() :derived2(5) {}
    friend ostream& operator<<(ostream& out, const Derived2& temp)
    {
        out << (Base&)temp;
        out << "======== DERIVED2 ========" << endl;
        out << temp.derived2 << endl;
        out << "======== DERIVED2 ========" << endl;
        return out;
    }
    friend ofstream& operator<<(ofstream& out, const Derived2& temp)
    {
        out << (Base&)temp;
        out << "======== DERIVED2 ========" << endl;
        out << temp.derived2 << endl;
        out << "======== DERIVED2 ========" << endl;
        return out;
    }
};
void main()
{
    Derived1 d1;
    Derived2 d2;
    Base* v[2];
    v[0] = &d1;
    v[1] = &d2;
    cout << *v[0] << endl;
    ofstream f("fis.txt");
    f << *v[0];
}

Answer 1

显示的代码存在几个问题

1）没有必要为std：：

ostream和std：：ofstream定义单独的运算符（这在其中一个评论中有所说明）

由于std::ostream是std::ofstream的超类，所以只需要为std::ostream实现一个运算符。

2）"使用命名空间标准"总是错误的做法。

3） main（） 函数应该返回一个 int。

现在，为了回答这里的主要问题，这里需要发生的只是使用虚拟继承。这就是虚拟继承的用途。你知道的。现在，正如您所指出的，仅仅因为运算符不能是虚拟的，绝对没有法律阻止他们自己调用虚拟方法。

Base的operator<<应该只是一些适当命名的函数的门面，例如format（），它将在类中作为虚拟方法实现。

最终结果如下所示：

#include<iostream>
#include<fstream>
class Base {
private:
    int base;
public:
    Base() :base(10){}
    friend std::ostream& operator<<(std::ostream& out, const Base& temp)
    {
        temp.format(out);
        return out;
    }
    virtual void format(std::ostream &out) const
    {
        out << "======== BASE ========" << std::endl;
        out << base << std::endl;
        out << "======== BASE ========" << std::endl;
    }
};
class Derived1 :public Base {
private :
    int derived1;
public:
    Derived1() :derived1(5){}
    void format(std::ostream &out) const override
    {
        out << "======== DERIVED1 ========" << std::endl;
        out << derived1 << std::endl;
        out << "======== DERIVED1 ========" << std::endl;
    }
};
class Derived2 :public Base {
private:
    int derived2;
public:
    Derived2() :derived2(5) {}
    void format(std::ostream &out) const override
    {
        out << "======== DERIVED1 ========" << std::endl;
        out << derived2 << std::endl;
        out << "======== DERIVED1 ========" << std::endl;
    }
};
int main()
{
    Derived1 d1;
    Derived2 d2;
    Base* v[2];
    v[0] = &d1;
    v[1] = &d2;
    std::cout << *v[0] << std::endl;
    std::ofstream f("fis.txt");
    f << *v[0];
}

Answer 2

由于您无法使流式处理运算符工作，因为它不是成员函数，因此无法成为虚拟函数，因此您必须使另一个函数成为虚拟函数，并从基的流运算符调用它。你可以称之为virtual void print()