c++ - 'this'指针是否参与虚函数多态行为

Question

我正在实现访问者模式，并且我有一个 accept() 函数，它只在 visitable 基类中定义。这个系统工作得很好，但 Alexandresku 在他的书中指出 this 指针具有静态类型。

这段代码是否有缺陷和/或有错误，但我的输出没有捕捉到它？

我试图改变对指针的引用，但输出没有改变。

.h文件

class WidgetVisitor
{
public:
    virtual void visit(ConcreteWidget1& w1);
    virtual void visit(ConcreteWidget2& w2);
    virtual void visit(Widget& w);
    virtual ~WidgetVisitor() { }
};


class Widget
{
public:
    Widget(const std::string& text);
    virtual std::string text() const;
    virtual void accept(WidgetVisitor* v);
protected:
    std::string text_;
};


class ConcreteWidget1: public Widget
{
public:
    ConcreteWidget1(const std::string& text);
    virtual std::string text() const override;

};

class ConcreteWidget2: public Widget
{
public:
    ConcreteWidget2(const std::string& text);
    virtual std::string text() const override;
};

.cpp文件

void WidgetVisitor::visit(ConcreteWidget1& w1) {
    cout << w1.text() << '\n';
}

void WidgetVisitor::visit(ConcreteWidget2& w2) {
    cout << w2.text() << '\n';
}

void WidgetVisitor::visit(Widget& w) {
    cout << w.text() << '\n';
}


Widget::Widget(const std::string& text): text_(text) { }

string Widget::text() const {
    return "Widget" + text_;
}

void Widget::accept(WidgetVisitor* v) {
    v->visit(*this);
    cout << "in the class " << text_ << '\n';
}

ConcreteWidget1::ConcreteWidget1(const string& text): Widget(text) { }

string ConcreteWidget1::text() const {
    return "ConcreteWidget1" + text_;
}

ConcreteWidget2::ConcreteWidget2(const string& text): Widget(text) { }

string ConcreteWidget2::text() const {
    return "ConcreteWidget2" + text_;
}

主要.cpp

int main() {

    WidgetVisitor* visitor = new WidgetVisitor();
    std::vector<Widget*> v;
    v.push_back(new Widget(" 1"));
    v.push_back(new ConcreteWidget1(" 2"));
    v.push_back(new ConcreteWidget2(" 3"));
    v.push_back(new ConcreteWidget1(" 4"));

    for (auto & w: v)
        w->accept(visitor);

    return 0;
}

输出是:

Widget 1
in the class  1
ConcreteWidget1 2
in the class  2
ConcreteWidget2 3
in the class  3
ConcreteWidget1 4
in the class  4

Answer 1

这实际上并不像您认为的那样有效。唯一被调用的访问者是 void WidgetVisitor::visit(Widget& w) 但由于 Widget::text() 方法是虚拟的，因此所有访问者方法实际上都具有相同的行为。

更改实现以输出引用参数类型的名称，您将看到:

void WidgetVisitor::visit(ConcreteWidget1& w1) {
    cout << "[cw1] " << w1.text() << '\n';
}

void WidgetVisitor::visit(ConcreteWidget2& w2) {
    cout << "[cw2] " << w2.text() << '\n';
}

void WidgetVisitor::visit(Widget& w) {
    cout << "[w] " << w.text() << '\n';
}

你得到这个输出:

[w] Widget 1
in the class  1
[w] ConcreteWidget1 2
in the class  2
[w] ConcreteWidget2 3
in the class  3
[w] ConcreteWidget1 4
in the class  4

如您所见，其他两个访问者重载根本没有被使用。

this 确实是静态类型的；如果它指向一个多态类型，那么在它上面调用的虚拟方法仍然使用动态调度进行调度，但是 Widget::accept() 实际上并没有在 this 上调用任何东西，它只是引用它。当您将此引用传递到其他地方时，它仍将被视为其静态类型，这意味着重载决策仍将在这里选择 Widget& 重载，因为 this 始终是 小部件*:

v->visit(*this);

这可以工作，但您必须在派生类中覆盖 Widget::accept()。例如:

class ConcreteWidget1: public Widget
{
public:
    ConcreteWidget1(const std::string& text);
    virtual std::string text() const override;
    virtual void accept(WidgetVisitor* v) override;
};

void ConcreteWidget1::accept(WidgetVisitor* v) {
    v->visit(*this);
    cout << "in the class " << text_ << '\n';
}

对 ConcreteWidget2 执行相同操作，现在您会注意到调用了正确的访问者重载:

[w] Widget 1
in the class  1
[cw1] ConcreteWidget1 2
in the class  2
[cw2] ConcreteWidget2 3
in the class  3
[cw1] ConcreteWidget1 4
in the class  4

现在您可以使 Widget::text() 成为非虚拟的并看到完全相同的输出。