使用继承和多态重载'<<'运算符？

Question

以下是代码的粗略示例，问题在于如何让DerivedOne和DerivedTwo有一个重载的<<运算符，但将这些对象存储在Base*的向量中。我想要实现的是，能够循环遍历对象向量并输出在DerivedOne和DerivedTwo中指定的信息。

vector<Base*> objects;

class Base
{
 private:
 object Data
 public:
 object getData() { return Data; }
};

class DerivedOne : public Base
{
}

class DerivedTwo : public Base
{
}

我知道有这个，但它对我的目的不起作用。

friend ostream &operator<<(ostream &stream, Object object)
{
    return stream << "Test" << endl;
}

- Baraphor

---

你尝试过在每个派生类中都有friend声明吗？我不是很确定，但如果你这样做，ADL会为你找到正确的函数。 - KRyan

请查看 https://dev59.com/OHI95IYBdhLWcg3w_zWs 的答案。 - Michał Wróbel

@DragoonWraith：我认为 ADL 在这里不起作用，因为 ADL 适用于“Base”的静态类型，而不是动态类型。 - Mooing Duck

Answer 1

将虚拟方法设置为私有，以区分对象的使用方式与其行为如何被派生类定制。

这是一个与其他答案类似的解决方案，但虚拟方法是私有的：

#include <iostream>

namespace {
  class Base {
    // private (there is no need to call it in subclasses)
    virtual std::ostream& doprint(std::ostream&) const = 0;
  public:
    friend std::ostream& operator << (std::ostream& os, const Base& b) {
      return b.doprint(os); // polymorphic print via reference
    }

    virtual ~Base() {} // allow polymorphic delete
  };


  class DerivedOne : public Base {
    std::ostream& doprint(std::ostream& os) const {
      return os << "One";
    }
  public:
    DerivedOne() { std::cerr << "hi " << *this << "\n"; } // use << inside class
    ~DerivedOne() { std::cerr << "bye " << *this << "\n"; }
  };
}

示例

#include <memory>
#include <vector>

int main () {
  using namespace std;
  // wrap Base* with shared_ptr<> to put it in a vector
  vector<shared_ptr<Base>> v{ make_shared<DerivedOne>() };
  for (auto i: v) cout << *i << " ";
  cout << endl;
}

输出

hi One
One 
bye One

- jfs

---

很久以前我就忘记了这个，但是你的回答帮助我想起来了，谢谢 :) - ervinbosenbacher

Answer 2

你可以像这样做：

你可以这样做：

struct Base {
    virtual ~Base () {}
    virtual std::ostream & output (std::ostream &) const = 0;
};

std::ostream & operator << (std::ostream &os, const Base &b) {
    return b.output(os);
}

然后，在对 Base 应用 operator<< 时，它将调用派生类的输出方法。

- jxh

---

请注意 operator<<() 参数列表中引用的使用。 - Code-Apprentice

Answer 3

根据您所描述的问题，您拥有一组动态分配的多态对象。解决方案取决于这些对象如何遵循某些设计规范：

1. 您的对象是否只是“叶子对象”（不涉及其他对象本身）？ 2. 是否只有单个非循环引用（您的对象是否仅形成子对象树）？ 3. 引用之间是否存在多条路径（同一对象被两个或更多对象引用）？ 4. 是否存在循环引用？ 5. 是否存在对其他对象成员的引用？

情况可能会变得非常复杂，具体取决于情况以及您是否能够容忍同一对象的多个输出以及如何打破事件循环。

首先，您不能将Base作为值参数使用（例如在您的示例中），因为这会创建一个副本（假设您的对象是可复制的：如果它们引用其他对象，那么复制会发生什么？增加路径数？也克隆所引用的对象吗？）

如果您处于情况（1），则只需要一个接收std::ostream&的虚函数，在所有叶子对象中进行重写。然后，您需要一个重载operator<<(std::ostream&, Base*)和另一个重载(std::ostream&, const std::vector&)。

代码如下：

class Base
{
    ...
public:
    virtual ~Base() {} //must be polymorphic
protected:
    virtual void out(std::ostream& s) =0;

    friend std::ostream& operator<<(std::ostream& st, Base* pb)
    { pb->out(st); return st; }
};

class Derived1: public Base
{
    ...
protected:
    virtual void out(std::ostream& s)
    {
        s << "Derived1 at " << this << " address " << std::endl;
    }
};


class Derived2: public Base
{
    ...
protected:
    virtual void out(std::ostream& s)
    {
        s << "Derived2 at " << this << " address " << std::endl;
    }
};

std::ostream& operator<<(std::ostream& s, const std::vector<Base*>& v)
{
    s << "there are " << v.size() << " objects:" << std::endl;
    for(auto& i:v)
        s << i;
    return s;
}

如果您处于情况（2.）中，可能会遇到一个问题。

class Derived3: public Base
{
    ...
    Base* ptrOwnedobject;
};

您可以简单地实现Derived3::out函数，以便递归到所拥有的子项。

如果您处于情况（3），并且无法容忍同一对象被多次打印或具有不同的父项共享相同的子项，那么您应该对子项进行标记，以便不会保存两次或更多次，并在完成打印后取消所有子项的标记（您最有可能将该机制设置为基类）。

如果您处于情况（4），那么必须避免无限递归，就像（3）中所说的那样。

如果您处于情况（5），则还必须发现成员属于哪个对象（不是很容易）。如果您还有多重继承和虚基类...事情会更加复杂。

- Emilio Garavaglia