“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_;
}

主程序

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;
}

输出是：

小部件 1
在第 1 类
具体小部件 1 2
在第 2 类
具体小部件2 3
在第 3 类
具体小部件 1 4
在第 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总是Widget*：

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()非虚拟并看到完全相同的输出。