一篇文章带你了解C++多态的实现原理

编辑: admin 分类: c#语言 发布时间: 2022-03-15 来源:互联网
目录
  • 虚函数和多态
  • 多态的作用
  • 多态的一个例子
  • 构造函数和析构函数中存在多态吗?
  • 多态的实现原理
    • 虚函数表
  • 虚析构函数
    • 纯虚函数和抽象类
      • 总结

        虚函数和多态

        虚函数:

        • 在类的定义中,前面有 virtual 关键字的成员函数称为虚函数
        • virtual 关键字只用在类定义里的函数声明中,写函数体时不用

        比如:

        class Base 
        {
            virtual int Fun() ; // 虚函数
        };
        int Base::Fun() // virtual 字段不用在函数体时定义
        { }
        
        • 多态的表现形式 派生类的指针」
        • 可以赋给「基类指针」通过基类指针调用基类和派生类中的同名「虚函数」时

        1.若该指针指向一个基类的对象,那么被调用是 基类的虚函数;

        2.若该指针指向一个派生类的对象,那么被调用 的是派生类的虚函数

        #include <iostream>
        using namespace std;
        class Animal
        {
        public:
        	virtual void speak()
        	{
        		cout << "动物在说话" << endl;
        	}
        };
        class Cat: public Animal
        {
        public:
        	void speak()
        	{
        		cout << "猫在叫" << endl;
        	}
        };
        void test01()
        {
        	Cat cat;
        	Animal* p = &cat;//Animal *p=new Cat
        	p->speak();//用哪个虚函数取决于 p 指向哪种类型的对象
        }
        int main()
        {
        	test01();
        }
        

        派生类的对象可以赋给基类「引用」通过基类引用调用基类和派生类中的同名「虚函数」时

        1.若该引用引用的是一个基类的对象,那么被调 用是基类的虚函数

        2.若该引用引用的是一个派生类的对象,那么被 调用的是派生类的虚函数

        比如:

        #include <iostream>
        using namespace std;
        class Animal
        {
        public:
        	virtual void speak()
        	{
        		cout << "动物在说话" << endl;
        	}
        };
        class Cat: public Animal
        {
        public:
        	void speak()
        	{
        		cout << "猫在叫" << endl;
        	}
        };
        void test01()
        {
        	Cat cat;
        	Animal& p = cat;
        	p.speak();
        }
        int main()
        {
        	test01();
        }
        

        多态的作用

        在面向对象的程序设计中使用「多态」,能够增强程序的可扩充性,即程序需要修改或增加功能的时候,需要改动和增加的代码较少。

        多态的一个例子

        比如:

        class Base 
        {
        public:
            void fun1() 
            { 
                fun2(); 
            }
            virtual void fun2()  // 虚函数
            { 
                cout << "Base::fun2()" << endl; 
            }
        };
        class Derived : public Base 
        {
        public:
            virtual void fun2()  // 虚函数
            { 
                cout << "Derived:fun2()" << endl; 
            }
        };
        int main() 
        {
            Derived d;
            Base * pBase = & d;
            pBase->fun1();
            return 0;
        }
        

        请问输出结果是什么?

        我们可能会认为pBase 指针对象虽然指向的是派生类对象,但是派生类里没有 fun1 成员函数,则就调用基类的 fun1 成员函数,Base::fun1() 里又会调用基类的 fun2 成员函数,所以输出结果是Base::fun2()

        但结果却是Derived:fun2(),为什么会这样?

        我们将代码修改一下

        class Base 
        {
        public:
            void fun1() 
            { 
                this->fun2();  // this是基类指针,fun2是虚函数,所以是多态
            }
        }
        

        this指针的作用域是在类内部,当在类的非静态成员函数中访问类的非静态成员的时候,编译器会自动将对象本身的地址作为一个隐含参数传递给函数,其作用就是指向成员函数所作用的对象,所以非静态成员函数中可以直接使用 this 来代表指向该函数作用的对象的指针。

        pBase 指针对象指向的是派生类对象,派生类里没有 fun1 成员函数,所以就会调用基类的 fun1 成员函数,在Base::fun1() 成员函数体里执行 this->fun2() 时,实际上指向的是派生类对象的 fun2 成员函数。

        所以我们需要注意:

        • 在非构造函数,非析构函数的成员函数中调用「虚函数」,是多态

        构造函数和析构函数中存在多态吗?

        在构造函数和析构函数中调用「虚函数」,不是多态。编译时即可确定,调用的函数是自己的类或基类中定义的函数,不会等到运行时才决定调用自己的还是派生类的函数。

        #include <iostream>
        using namespace std;
        // 基类
        class CFather
        {
        public:
            virtual void hello() // 虚函数
            {
                cout << "hello from father" << endl;
            }
            virtual void bye() // 虚函数
            {
                cout << "bye from father" << endl;
            }
        };
        // 派生类
        class CSon : public CFather
        {
        public:
            CSon() // 构造函数
            {
                hello();
            }
            ~CSon()  // 析构函数
            {
                bye();
            }
            virtual void hello() // 虚函数
            {
                cout << "hello from son" << endl;
            }
        };
        int main()
        {
            CSon son;
            CFather* pfather;
            pfather = &son;
            pfather->hello(); //多态
            return 0;
        }
        

        结果为:

        hello from son // 构造son对象时执行的构造函数
        hello from son // 多态
        bye from father // son对象析构时,由于CSon类没有bye成员函数,所以调用了基类的bye成员函数

        多态的实现原理

        「多态」的关键在于通过基类指针或引用调用一个虚函数时,编译时不能确定到底调用的是基类还是派生类的函数,运行时才能确定。

        class A 
        {
        public:
            int i;
            virtual void Print() { } // 虚函数
        };
        class B
        {
        public:
            int n;
            void Print() { } 
        };
        int main() 
        {
            cout << sizeof(A) << ","<< sizeof(B);
            return 0;
        }
        

        在32位机子中:8 4

        从上面的结果,可以发现有虚函数的类,多出了4 个字节,在 32 位机子上指针类型大小正好是 4 个字节,这多出 4 个字节的指针有什么作用呢?

        虚函数表

        每一个有「虚函数」的类(或有虚函数的类的派生类)都有一个「虚函数表」,该类的任何对象中都放着虚函数表的指针。「虚函数表」中列出了该类的「虚函数」地址。

        多出来的 8 个字节就是用来放「虚函数表」的地址。

        // 基类
        class Base 
        {
        public:
            int i;
            virtual void Print() { } // 虚函数
        };
        // 派生类
        class Derived : public Base
        {
        public:
            int n;
            virtual void Print() { } // 虚函数
        };
        

        上面 Derived 类继承了 Base类,两个类都有「虚函数」,那么它「虚函数表」的形式可以理解成下图:

        在这里插入图片描述

        多态的函数调用语句被编译成一系列根据基类指针所指向的(或基类引用所引用的)对象中存放的虚函数表的地址,在虚函数表中查找虚函数地址,并调用虚函数的指令

        虚析构函数

        析构函数是在删除对象或退出程序的时候,自动调用的函数,其目的是做一些资源释放。

        那么在多态的情景下,通过基类的指针删除派生类对象时,通常情况下只调用基类的析构函数,这就会存在派生类对象的析构函数没有调用到,存在资源泄露的情况。

        比如:

        // 基类
        class A 
        {
        public: 
            A()  // 构造函数
            {
                cout << "construct A" << endl;
            }
            ~A() // 析构函数
            {
                cout << "Destructor A" << endl;
            }
        };
        // 派生类
        class B : public A 
        {
        public: 
            B()  // 构造函数
            {
                cout << "construct B" << endl;
            }
            ~B()// 析构函数
            {
                cout << "Destructor B" << endl;
            }
        };
        int main() 
        {
            A *pa = new B();
            delete pa;
            return 0;
        }
        

        输出结果:

        construct A
        construct B
        Destructor A

        从上面的输出结果可以看到,在删除 pa指针对象时,B 类的析构函数没有被调用

        解决办法:把基类的析构函数声明为virtual

        • 派生类的析构函数可以 virtual 不进行声明
        • 通过基类的指针删除派生类对象时,首先调用派生类的析构函数,然后调用基类的析构函数,还是遵循「先构造,后虚构」的规则
        // 基类
        class A 
        {
        public: 
            A()  
            {
                cout << "construct A" << endl;
            }
            virtual ~A() // 虚析构函数
            {
                cout << "Destructor A" << endl;
            }
        };
        

        输出结果:

        construct A
        construct B
        Destructor B
        Destructor A

        纯虚函数和抽象类

        纯虚函数: 没有函数体的虚函数

        class A 
        {
        public:
            virtual void Print( ) = 0 ; //纯虚函数
        private: 
            int a;
        };
        

        包含纯虚函数的类叫抽象类

        • 抽象类只能作为基类来派生新类使用,不能创建抽象类的对象
        • 抽象类的指针和引用可以指向由抽象类派生出来的类的对象
        A a;         // 错,A 是抽象类,不能创建对象
        A * pa ;     // ok,可以定义抽象类的指针和引用
        pa = new A ; // 错误, A 是抽象类,不能创建对象
        

        总结

        本篇文章就到这里了,希望能给你带来帮助,也希望您能够多多关注海外IDC网的更多内容!