派生类中的运算符重新定义但仍使用父类

Question

具体来说，我希望能够在基类的两个派生类中使用ostream运算符<<。

我正在创建的程序应该打印“虚拟商店”中各种“产品”的产品详细信息。产品中有两种不同类型的书籍。这些书籍中的每一本书都应该保留自己的内容：

ID number
Author
NumberOfPages
Year

此外，类型 ChildrensBook 需要保留最低年龄，而 TextBook 需要保留等级。

我定义了 Book 类，并从它派生了 ChildrensBook 和 TextBook 类。我的问题是关于使用 ostream operator << 打印出信息。

我可以定义一个通用的 << Book 类中的函数，它将打印出两个派生类共有的所有信息，然后在 << 的重新定义中引用它。在派生类中？

例如，

//The parent class

ostream& operator<<(ostream& bookOutput, const Book& printBook) {
    return bookOutput << printBook.ID << "Name " << printBook.name << "year:" << printBook.year";
}

然后在派生类中以某种方式：

//The derived classes
ostream& operator<<(ostream& TextBookOutput, const TextBook& printTextBook) {
    return TextBookOutput << "TextBook: " 
           << "[Here is where I want to print out all the details of the book that are members of the base class]" << "Grade:" << printTextBook.grade;
}

所以我想我的问题可以总结为：我可以从子运算符中调用父运算符吗？如果可以，我应该使用什么语法？

我想到的另一个想法是为使用父打印运算符的子进程编写一个函数，然后从子进程的打印运算符中调用该函数。这意味着我在重新定义操作符时并没有尝试调用它，但仍然要求使用父操作符并单独重新定义子操作符。

Answer 1

当然。

您有一个用于 Book 的运算符，因此请使用它。您可以通过给它提供对一本书的引用来调用它，并且可以使用多态性的力量来获取对基的引用。

ostream& operator<<(ostream& TextBookOutput, const TextBook& printTextBook) {
    return TextBookOutput << "TextBook: " << static_cast<const Book&>(printTextBook) << "Grade:" << printTextBook.grade;
}

Answer 2

return TextBookOutput << static_cast<Book const &>(printTextBook) << ...

Answer 3

正如其他人指出的那样，您应该使用向下转型来实现您的要求。但我认为你也应该考虑一种不同的方法：你现在正在做的是混合静态和动态多态性，这通常不是一个好主意（通常稍后才会显现出来）。

问题是这样的，考虑一下你已经拥有的东西：
<代码>

class Book { ... };
class TextBook : public Book { ... };
ostream& operator<<(ostream& os, const Book& book) {
    return os << "Book: " << book.name << "\n";
}
ostream& operator<<(ostream& os, const TextBook& book) {
    return os << "TextBook: " << book.name << "\n";
}

Everything will go as expected if you use it like this:

Book book;
TextBook textBook;
cout << book << "\n";     // prints out: Book: XYZ
cout << textBook << "\n"; // prints out: TextBook: XYZ 

That is because the compiler will correctly determine the type of the book during compilation time (statically).

现在考虑另一种情况：
<代码>

Book * textBook = new TextBook();
cout << *textBook << "\n";    // prints out: Book: XYZ !

这是因为编译器无法知道它是什么更高类型，它可以是 Book、TextBook 或 ChildrensBook。这只能在运行时（动态）使用虚拟函数等来确定。

因此，如果您考虑利用动态多态性，我更喜欢这种方法：
<代码>

class Book {
  public:
  virtual ostream& print(ostream& os) const { return os << "Book: XYZ"; }
  // Don't forget virtual destructor.
  virtual ~Book() {}
};
class TextBook : public Book {
  public:
  virtual ostream& print(ostream& os) const
  {
    // Here, you can also call the "print" method of the parent class
    // like this: os << Book::print(os);
    // or just invent your own like this:
    return os << "TextBook: XYZ";
  }
};
ostream& operator<<(ostream& os, const Book& book) {
  // Will correctly decide during runtime whether
  // to use Book::print or TextBook::print.
  return book.print(os);
}