Doees the 'this' 指针参与虚函数的多态行为

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

本文关键字：函数 多态 the this 指针 Doees      更新时间：2023-10-16

>我正在实现访问者模式，我有一个仅在基visitable类中定义的accept()函数。这个系统工作得很好，但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;
}

输出为：

小部件 1 在 1 类 具体小部件1 2 在 2 类 具体小部件2 3 在 3 类 具体小部件1 4 在 4 类

这实际上并不像您认为的那样有效。 唯一被调用的访问者是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()非虚拟的，并看到完全相同的输出。

相关文章：