4

我将很多来自 Java 的假设带到了我对 C++ 的学习中，这似乎再次难倒了我。我没有足够的词汇量来雄辩地说出我希望从以下程序中看到的内容，所以我只是呈现它并说出我希望看到的内容：

#include <iostream>
#include <vector>

using namespace std;

class Piece {};

class Man : public Piece {};

class Square {
  Piece p;
public:
  Square(Piece p) : p(p) { };
  Piece get_piece() const { return p; }
};

ostream& operator<<(ostream& os, const Piece& p)
{
  cout << "Piece";
  return os;
}

ostream& operator<<(ostream& os, const Man& m)
{
  cout << "Man";
  return os;
}

ostream& operator<<(ostream& os, const Square& s)
{
  cout << s.get_piece() << '\n';
  return os;
}

int main()
{
  Square sq = Square(Man());
  cout << sq;
}

当我运行这个程序时，输出是Piece，但我希望看到Man。这是否称为运行时多态性？我认为这是保留给功能的，但我不知道。Java 中的“等效”程序打印出我所期望的Man，但我不知道如何让这个 C++ 程序做到这一点。我错过了什么？

4

2 回答 2

6

与Java 不同，C++ 区分对对象和值的引用，即对象本身。当您将派生类型的对象传递给采用基类型值的函数时，您会得到一个切片对象：它将只包含对象基本部分的副本，而没有派生类型的任何内容。例如，您的构造函数

Square(Piece piece)

按值获取它的参数，它将始终是类型Piece，并且永远不会是任何派生类型：参数，如果它是派生类型，则被切片。您可以使用如下符号通过引用传递对象

Square(Piece& piece)

如果引用的对象piece是可变的或

Square(Piece const& piece)

如果被引用的对象piece应该是不可变的。在您的上下文中，您很可能还希望处理对象的生命周期管理，这可能最好使用在堆上分配的对象来完成，使用new一些智能指针并由其维护，例如 std::shared_ptr`。

现在到你的输出函数：被调用的函数总是基于静态类型静态解析，即在编译期间声明和可见的类型。一旦调用了正确的函数，如果它恰好被声明virtual，它就会根据对象的动态类型分派给一个可能的覆盖函数，即虚拟分派是在运行时完成的。出于您输出运算符的目的，这意味着它们仅根据静态类型进行选择，在您的情况下始终为Piece. 处理这个问题的常用方法是使用一个virtual函数并从实际的输出运算符分派到这个函数，例如：

class Piece {
protected:
    virtual std::ostream& do_print(std::ostream& out) const  = 0;
public:
    std::ostream& print(std::ostream& out) const { return this->do_print(out); }
};
std::ostream& operator<< (std::ostream& out, Piece const& piece) {
    return piece.print(out);
}

class Man: public Piece {
protected:
    std::ostream& do_print(std::ostream& out) {
        return out << "Man";  // note: you want to use out, not std::cout here
    }
};

使用此设置，您可以使用对此类型对象的引用来调用静态输出运算符Piece并获取由动态类型选择的输出，例如：

class Square {
    std::shared_ptr<Piece> d_piece;
public:
    Square(std::shared_ptr<Piece> piece): d_piece(piece) {}
    Piece const& get_piece() const { return *this->d_piece; }
};
std::ostream& operator<< (std::ostream& out, Square const& square) {
    return out << square.get_piece();
}

有点古怪的print()todo_print()并不是真正需要的，但是如果您有多个virtual具有相同名称的重载并且您只覆盖其中一个，则基类中的所有其他版本都将被隐藏。由于print()没有被覆盖，do_print()也没有被用户调用，隐藏重载的问题在一定程度上减少了。

于 2013-08-18T00:33:46.320 回答
5

这都是关于“静态多态性”，也就是方法重载。的特定版本operator<<由编译器根据它看到的变量的编译时类型来选择；因为get_piece()返回Piece，operator<<那就是选择的版本。

我必须指出你对等价的 Java 程序是错误的：Java 方法重载也由编译器仲裁，并且基于编译时类型。一个真正等效的 Java 程序也会显示Piece。

于 2013-08-18T00:30:42.370 回答