C++ C++；-能以不同的方式执行功能吗？

在此代码中：

void Window::oops()  { printf("Window oops\n"); } 
void TextWindow::oops() { 
printf("TextWindow oops %d\n", cursorLocation);
}
TextWindow x; 
Window      a; 
Window     *b; 
TextWindow *c; 
a = x; a.oops();   // executes Window version 
b = &x; b->oops(); // executes TextWindow or Window version 
c = &x; c->oops(); // executes TextWindow version

b=&x；b->oops（）将执行文本窗口或窗口版本？如何决定
 如果
oops（）
是虚拟的，则
b->oops（）
调用将使用
TextWindow
版本。如果不是，它将使用
窗口
版本。
如果
oops（）
是虚拟的，
b->oops（）
调用将使用
文本窗口
版本。如果不是，它将使用
窗口
版本

a = x; a.oops();   // executes Window version 

这会导致对象切片。请参阅此wiki条目：

使用此函数，可以多态地调用虚拟函数。它将调用文本窗口版本，而不是窗口版本

c = &x; c->oops(); // executes TextWindow version

它只是使用与对象的动态类型相同的指针调用虚函数，在本例中，如果
TextWindow
，则调用虚函数

这会导致对象切片。请参阅此wiki条目：

使用此函数，可以多态地调用虚拟函数。它将调用文本窗口版本，而不是窗口版本

c = &x; c->oops(); // executes TextWindow version

它只是使用与对象的动态类型相同的指针调用虚函数，在这种情况下，如果
TextWindow
，它是基本的：

b作为指向窗口的指针，它可以指向窗口对象或从窗口继承的类型的对象。然后，继承的类型可以重新实现oops（）函数（如果在窗口定义中指定了oops（））

允许这样，C++编译器将添加附加信息来路由对象数据中的函数调用，几乎总是以.< /p>的形式进行。
这允许您操作一组窗口，调用基本成员函数，而不必担心对象最终会做什么。然后，该对象可以针对其特定的子类型以特定的方式实现函数
请参阅wikipedia页面中的简单示例：
它是基本的：

b作为指向窗口的指针，它可以指向窗口对象或从窗口继承的类型的对象。然后，继承的类型可以重新实现oops（）函数（如果在窗口定义中指定了oops（））

允许这样，C++编译器将添加附加信息来路由对象数据中的函数调用，几乎总是以.< /p>的形式进行。
这允许您操作一组窗口，调用基本成员函数，而不必担心对象最终会做什么。然后，该对象可以针对其特定的子类型以特定的方式实现函数
请参阅维基百科页面中的简单示例：
虽然没有特别说明，但我假设
TextWindow
是（直接或间接）从
Window
派生出来的

在这种情况下，基本问题是
oops（）
是否为虚拟成员函数

如果
oops（）
是虚拟的，那么通过指针或引用的调用基于动态类型——指针/引用实际引用的对象的类型

如果
oops（）
不是虚拟的，那么通过指针或引用进行的调用基于静态类型——指针定义指向的对象类型，而不管它实际指向的对象类型

struct Window { 
    void oops() { std::cout << "Window::oops()\n"; }
    virtual void oops2() { std::cout << "Window::oops2()\n"; }
};

struct TextWindow : Window { 
    void oops() { std::cout << "TextWindow::oops()\n"; }
    virtual void oops2() { std::cout << "TextWindow::oops2()\n"; }
};

int main() { 
    Window w;
    w.oops();      // Both of these print "Window::...".
    w.oops2();

    TextWindow tw;
    tw.oops();     // Both of these print "TextWindow::...".
    tw.oops2(); 

    Window &w2 = tw;
    w2.oops();     // oops() is not virtual, and we're using a reference to a Window, 
                   // so this invokes Window::oops().

    w2.oops2();    // oops2() is virtual, so even though w2 is a reference to a
                   // Window, this invokes TextWindow::oops2(), because the reference
                   // refers to the object tw, which is a TextWindow.

    return 0;
}

结构窗口{code>
void oops（）{std:：cout虽然没有特别说明，但我假设
TextWindow
是从
Window
直接或间接派生出来的

在这种情况下，基本问题是
oops（）
是否为虚拟成员函数

如果
oops（）
是虚拟的，那么通过指针或引用的调用基于动态类型——指针/引用实际引用的对象的类型

如果
oops（）
不是虚拟的，那么通过指针或引用进行的调用基于静态类型——指针定义指向的对象类型，而不管它实际指向的对象类型

struct Window { 
    void oops() { std::cout << "Window::oops()\n"; }
    virtual void oops2() { std::cout << "Window::oops2()\n"; }
};

struct TextWindow : Window { 
    void oops() { std::cout << "TextWindow::oops()\n"; }
    virtual void oops2() { std::cout << "TextWindow::oops2()\n"; }
};

int main() { 
    Window w;
    w.oops();      // Both of these print "Window::...".
    w.oops2();

    TextWindow tw;
    tw.oops();     // Both of these print "TextWindow::...".
    tw.oops2(); 

    Window &w2 = tw;
    w2.oops();     // oops() is not virtual, and we're using a reference to a Window, 
                   // so this invokes Window::oops().

    w2.oops2();    // oops2() is virtual, so even though w2 is a reference to a
                   // Window, this invokes TextWindow::oops2(), because the reference
                   // refers to the object tw, which is a TextWindow.

    return 0;
}

结构窗口{code>
void oops（）{std:：cout-1表示
，如果不是，它将使用窗口版本
，因为它将调用
文本窗口
版本。@Nawaz:不会。如果函数不是虚拟的，它将使用窗口版本，因为b类型为Window*-1表示
，如果不是，它将使用窗口版本
，因为它将调用
文本indow
version.@Nawaz:不，它不会。如果函数不是虚拟的，它将使用窗口版本，因为b的类型是Window*
b->oops（）
仅当
oops（）时才会调用TextWindow版本
是虚拟的，我们无法判断它是否来自问题中的代码段。我没有看到
oops
声明为
virtual
。无法从发布的代码段OP中确定类是否是
多态的。
b->oops（）
仅当
oops（）时才会调用TextWindow版本
是虚拟的，我们无法判断它是否来自问题中的代码段。我没有看到
oops
声明为
virtual
。无法从发布的代码段确定类是否是多态的。