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()返回Pieceoperator<<那就是选择的版本。

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

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