C++ 基本面向对象继承

考虑以下源代码。我有两个班CBar和CFoo。CFoo继承自CBar。此源代码的输出是

Bar 
Foo 
Bar 

我期待着

Bar 
Foo 
Foo

我哪里出错了？ 我当时想的是，因为CFoo对象有一个Speak函数，它覆盖了CBar Speak函数。当我从一个CBar函数对一个CFoo对象调用Speak（）函数时，将执行CFoo Speak函数。但这一假设似乎是错误的

class CBar
{
    public:
        void Speak() { 
            printf(" Bar \n"); 
        }

        void DoStuff() {
            this->Speak(); 
        }
};


class Cfoo : public CBar 
{
    public:
        void Speak() { 
            printf(" Foo \n"); 
        }

        void DoStuff() {
            CBar::DoStuff(); 
        }
};



int _tmain(int argc, _TCHAR* argv[])
{
    CBar b;
    b.Speak(); 

    Cfoo f;
    f.Speak();

    f.DoStuff(); 
    return 0;
}

---

在C++中，需要使用<代码>虚拟< /> >以启用多态性。否则，所有

Speak（）

在

CFoo中执行的操作都将
Speak（）
隐藏在
CBar
中

class CBar 
{ 
    public: 
        virtual void Speak() {  // Note virtual keyword
            printf(" Bar \n");  
        } 

        void DoStuff() { 
            this->Speak();  
        } 
}; 


class Cfoo : public CBar  
{ 
    public: 
        void Speak() {  // Overrides the virtual method Speak()
            printf(" Foo \n");  
        } 

        void DoStuff() { // Hides CBar::DoStuff() method
            CBar::DoStuff(); 
        } 
}; 



int _tmain(int argc, _TCHAR* argv[]) 
{ 
    CBar b; 
    b.Speak();  

    // Speak() is a virtual function, so calling Speak() on a CFoo or
    // a CBar pointer will call the most derived implementation of Speak(). 
    Cfoo f; 
    f.Speak(); 

    /* My example */
    // Since CFoo "is-a" CBar, this conversion is safe.
    CBar* bar = &f;
    // Since Speak() is a virtual function, this will call CFoo's implementation
    // of Speak(), not CBar's.
    bar->Speak();
    /* End example */

    // Because CBar::DoStuff() is hidden, this calls CFoo::DoStuff() instead.
    f.DoStuff();
    return 0; 
} 

Speak
不是多态函数

也就是说，因为它没有标记为
virtual
，对它的任何调用都是静态确定的。所以在
CBar
中，
this->Speak（）将始终引用
CBar:：Speak

如果将函数设置为虚拟函数，则将根据动态类型而不是静态类型选择对函数的调用，并将进行您期望的调用。
谢谢，我知道这将是一件简单的事情。