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

Question

我正在实施访问者模式，并且我有一个 accept() 函数，它只在基础 visitable class 中定义。该系统运行良好，但 Alexandresku 在他的书中指出 this 指针具有静态类型。

这段代码有缺陷吗and/or有错误，但我的输出没有捕捉到它？

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

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

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

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

Doees the 'this' pointer participate in a virtual function's polymorphic behavior

c++

virtual

this