您的位置: 首页  >  文章  >  C++ 三大特性 封装、继承和多态 详细总结

C++ 三大特性 封装、继承和多态 详细总结

分类: 文章 • 2024-02-20 22:44:22

转自：https://blog.****.net/uestclr/article/details/51553978


面向对象三大特征：封装，继承，多态；

一、封装：该公开的就公开话，该私有的就隐藏掉，主要是由public，private实现；作用是便于分工和分模块，防止不必要的扩展；

二、继承：就是一种传承，可以把父类型中的数据传承到子类中，子类除了传承了父类的数据之外，还可以对父类型进行扩展；

公开继承  public

保护继承  protected

私有继承  private

保护成员：在子类和本类中可以访问，其他不行；


1、公开继承：在公开继承下，父类型中的数据是公开的到子类型中权限是公开的；父类型中保护权限的数据到子类中是保护的；父类中私有的数据到子类中会隐藏掉（就是说看不见权限，但是实际上式在子类中的）；

2、私有继承：在私有继承下，父类中的公开数据到子类中变成私有的，父类中的保护数据到子类中称为私有的，父类中的私有数据到子类中隐藏；

3、保护继承：保护继承下，父类中的公开数据和保护数据到了子类中都成为保护权限，父类中私有的数据到了子类中就变成了隐藏的；


4、注意：不管何种类型的继承关系，父类私有成员到子类中都成为了隐藏掉。

公开继承下的public成员和protected成员的权限变化：

[cpp] view plain copy
  1. #include <iostream>  
  2. using namespace std;  
  3.   
  4. class A{  
  5. public:  
  6.     int a;  
  7.     int geta(){  
  8.         a = 300;  
  9.         return a;  
  10.     }  
  11.     /*保护类型成员在本类和子类中可以访问*/  
  12. protected:  
  13.     int b;  
  14. private:  
  15.     int c;  
  16. };  
  17.   
  18. class B:public A{  
  19.     //int x;  
  20. public:  
  21.     void getb(){  
  22.         b = 200;  
  23.     }  
  24.     void show(){  
  25.         cout << b << endl;  
  26.     }  
  27.     void showa(){  
  28.         cout<< a<<endl;  
  29.     }  
  30. };   
  31. /*关键在于如何设置接口，成功合理的访问到各种类型的数据*/  
  32. int main(){  
  33.     B pex;  
  34.     /*公开继承public成员依旧是public，所以可以类外访问*/  
  35.     pex.a = 100;  
  36.     /*b是保护类型成员，可以通过设置public接口来访问*/  
  37.     pex.getb();  
  38.     pex.show();  
  39.     /*隐藏成员的问题，怎么访问到隐藏的成员*/  
  40.     pex.geta();  
  41.     pex.showa();  
  42.     //A a = pex;//子类类型赋给了父类类型  
  43.     //a.geta();  
  44.     //cout << a.a << endl;  
  45. }  


5、私有继承下的成员的权限变化关系，注意如何设置合理的 访问接口去访问 隐藏的数据成员。

[cpp] view plain copy
  1. /*私有继承下的权限变化，关键是设置合理的接口访问 
  2. 父类中的各种类型的数据成员*/  
  3. #include <iostream>  
  4. using namespace std;  
  5.   
  6. class A{  
  7. private:  
  8.     void showa(){  
  9.         cout << "this is showa()" << endl;  
  10.     }  
  11. protected:  
  12.     void showb(){  
  13.         cout << "this is showb" << endl;  
  14.     }  
  15. public:  
  16.     void showc(){  
  17.         cout << "this is showc" << endl;  
  18.     }  
  19.     void geta(){//设置合理的接口访问A中的私有数据  
  20.         showa();  
  21.     }  
  22. };  
  23.   
  24. class B:private A{  
  25. public:  
  26.     void show(){  
  27.         showc();  
  28.         showb();  
  29.         geta();  
  30.     }  
  31. };  
  32.   
  33. int main(){  
  34.     B b;  
  35.     //A a = b;对比公开继承，对比一下  
  36.     b.show();  
  37. }  

6、突破成员访问权限，可以设置合理的访问接口，也可以使用友元类。

[cpp] view plain copy
  1. /*友元类*/  
  2. #include <iostream>  
  3. using namespace std;  
  4.   
  5. class A{  
  6. private:  
  7.     int x;  
  8.     int y;  
  9. public:  
  10.     A():x(10),y(123){}  
  11.     /*B,C声明为A的友元类之后，可以访问到父类的所有类型成员*/  
  12.     friend class B;  
  13.     friend class C;  
  14. };  
  15.   
  16. class B:public A{  
  17. public:  
  18.     void show(){  
  19.         cout << x << "---" << y << endl;   
  20.     }  
  21. };  
  22.   
  23. class C{  
  24. public:  
  25.     void show(){  
  26.         A a;  
  27.         cout <<a.x<< "---" << a.y << endl;  
  28.     }  
  29. };  
  30.   
  31. int main(){  
  32.     B b;  
  33.     b.show();  
  34.     C c;  
  35.     c.show();  
  36. }  

7、继承中构造函数、析构函数、赋值运算符函数和拷贝构造函数

构造函数和析构函数是不能被继承的，但是可以被调用。并且子类一定会调用父类的构造函数；

子类默认调用父类的无参构造，也可以制定调用构造函数；

析构函数的调用和构造函数的调用顺序相反；

拷贝构造函数和赋值运算符函数也不能被继承：在子类不提供拷贝构造和赋值运算符时，子类默认调用父类的赋值运算符和拷贝构造函数。但子类一旦提供拷贝构造和赋值运算符函数则不再调用父类拷贝构造和赋值运算符函数。

[cpp] view plain copy
  1. /*继承中构造函数和析构函数的调用：构造函数和析构函数不可以 
  2. 被继承，但是可以被调用，而且子类肯定会调用父类的构造函数 
  3. 和析构函数。这种机制可以很自然的用于访问父类的私有成员*/  
  4. #include <iostream>  
  5. using namespace std;  
  6.   
  7. class A{  
  8. private:  
  9.     int x;  
  10. public:  
  11.     //A(){cout << "A()" << endl;}  
  12.     A(int x = 0):x(x){  
  13.         cout <<"A()构造"<<endl;  
  14.         cout << x << endl;}  
  15.     ~A(){cout << "~A()" << endl;}  
  16.     int _get(){  
  17.         return x;  
  18.     }  
  19. };  
  20.   
  21. class B:public A{  
  22. public:  
  23.     /*在初始化参数列表中可以指定调用父类的构造函数,指定调用构造函数并且给 
  24.     父类中的私有成员赋值*/  
  25.     /*注意：子类默认调用父类的无参构造，如果下面的代码没有：A(100),则会调用无参构造，但是父类无参构造 
  26.     被注释掉，所以会出错*/  
  27.     B():A(100){  
  28.         //x = 200;  
  29.         //A(100);  
  30.         cout << "B()" << endl;  
  31.     }  
  32.     //访问有参构造的方式,理解这种方式的作用  
  33.     /*注意，这种机制下的构造函数所赋的值是赋到了子类中的数据x中， 
  34.     而父类中的x仍然为0*/  
  35.     ~B(){cout << "~B()" << endl;}  
  36.     int getbx(){  
  37.         return _get();  
  38.     }  
  39. };  
  40. int main(){  
  41.     A a;//构建A对象，此时A类构造被调用，并打印出了值  
  42.   
  43.     B b;//B类为无参构造，首先调用了A的构造，在调用B的构造  
  44.   
  45.     //打印a对象中的x成员  
  46.     cout <<a._get()<<endl;//a对象中的x为0  
  47.   
  48.     //打印b对象中的x  
  49.     cout << b.getbx()<<endl;//是100  
  50.     /*一层一层的退，先调用b的析构，在调用a的析构*/  
  51. }  
拷贝构造和赋值运算符的问题

[cpp] view plain copy
  1. #include <iostream>  
  2. using namespace std;  
  3. /*系统一旦提供构造函数，系统默认的构造函数将被回收 
  4. 记住，拷贝构造也是构造函数*/  
  5. class A{  
  6.     int arr;  
  7. public:  
  8.     A(){}  
  9.     //A(int x = 0):arr(x){}  
  10.     A(const A& a){  
  11.         cout << "父类拷贝构造" << endl;  
  12.     }  
  13.     void operator=(const A& a){  
  14.         cout << "父类赋值运算符函数" << endl;  
  15.     }  
  16. };  
  17. /*有指针类型的成员时，采用默认机制就麻烦了*/  
  18. class B:public A{  
  19.     //int * pi;  
  20. public:  
  21.     B(){}  
  22.     B(const B& b):A(b){                        
  23.         //子类中提供了拷贝构造函数将不再调用父类的拷贝构造  
  24.         cout << "子类拷贝构造" << endl;  
  25.     }  
  26.     void operator=(const B& b){  
  27.         A::operator=(b);         //调用父类的拷贝构造函数的机制  
  28.         cout << "子类赋值运算符函数"<< endl;  
  29.     }  
  30. };  
  31.   
  32. int main(){  
  33.     B a;  
  34.     B b = a;  
  35.     B c;  
  36.     c = a;  
  37. }  

8，名字隐藏

名字隐藏机制：子类中如果定义了和父类中同名的数据，这些数据包括成员变量和成员函数。则会把父类中的数据隐藏掉。

注意：只要名字相同，计算返回值或者形参列表不同，也会被隐藏。隐藏不代表就没有了，可以通过类名作用域::访问到被隐藏的成员。

[cpp] view plain copy
  1. #include <iostream>  
  2. using namespace std;  
  3.   
  4. class A{  
  5. public:  
  6.     int x;  
  7.     int show(){  
  8.         cout << "show A" << endl;  
  9.         return 0;  
  10.     }  
  11.     A(){x=20;}  
  12.     A(int x):x(x){cout << "show A(int x)" << endl;}  
  13.     void shouu(){  
  14.         cout <<"shouu()"<<endl;  
  15.     }  
  16. };  
  17.   
  18. class B:public A{  
  19. public:  
  20.     int x;  
  21.     int y;  
  22.     B(){cout << "B()" << endl;}  
  23.     void show(){  
  24.         cout << "show B" << endl;  
  25.         //A::show();  
  26.     }  
  27. };  
  28.   
  29. int main(){  
  30.     B b;  
  31.     b.shouu();  
  32.     //cout << b.x << endl;  
  33.     //cout << b.A::x << endl;   //突破名字隐藏机制  
  34.     //int c = b.show();被隐藏，无法访问  
  35.     //b.A::show();  
  36. }  

9、多继承和函数重写

多继承是c++特有的语法机制，表现为一个子类有多个直接的父类。

[cpp] view plain copy
  1. #include <iostream>  
  2. using namespace std;  
  3.   
  4. class phone{  
  5.     double price;  
  6. public:  
  7.     //phone();  
  8.     phone(double price = 15):price(price){cout << "phone" << endl;}  
  9.     ~phone(){cout << "~phone" << endl;}  
  10.     void call(){  
  11.         cout << "use calling" << endl;  
  12.     }  
  13.     double getprice(){  
  14.         return price;  
  15.     }  
  16. };  
  17.   
  18. class MP3{  
  19.     double price;  
  20. public:  
  21.     MP3(double price = 20):price(price){cout << "MP3" << endl;}  
  22.     ~MP3(){cout << "~MP3" << endl;}  
  23.     void play(){  
  24.         cout << "use to listening music" << endl;  
  25.     }  
  26.     double getprice(){  
  27.         return price;  
  28.     }  
  29. };   
  30.   
  31. class vedio{  
  32.     double price;  
  33. public:  
  34.     vedio(double price = 0):price(price){cout << "vedio" << endl;}  
  35.     ~vedio(){cout << "~vedio" << endl;}  
  36.     void vcd(){  
  37.         cout << "watch vedio" << endl;  
  38.     }   
  39.     double getprice(){  
  40.         return price;  
  41.     }  
  42. };  
  43. /*多继承*/  
  44. class iphone:public phone,public MP3,public vedio{  
  45. public:  
  46.     double getprice(){  
  47.         return phone::getprice() + MP3::getprice() + vedio::getprice();  
  48.     }  
  49. };  
  50.   
  51. int main(){  
  52.     iphone iphone6;  
  53.     //cout << sizeof(iphone) << endl;  
  54.     cout << iphone6.MP3::getprice() << endl;  
  55.     cout << iphone6.phone::getprice() << endl;  
  56.     cout << iphone6.getprice() << endl;    //用名字隐藏机制解决多分数据同名冲突的问题  
  57. }  

多继承遇到的问题：上面的代码用sizeof就可以看到，子类在多继承的时候会多次复制顶层数据，而我们期望的是price这个成员只需要复制一份就可以了，因为多余的复制是无意义的。首先采用顶层抽象的方式，将三个父类抽象到更高的层面上。

[cpp] view plain copy
  1. #include <iostream>  
  2. using namespace std;  
  3. /*抽象到更高层的类中*/  
  4. class product{  
  5.     double price;  
  6. public:  
  7.     double getprice(){  
  8.         return price;  
  9.     }  
  10.     product(double price = 0):price(price){cout <<"product"<<endl;}  
  11. };  
  12. class phone:public product{  
  13. public:  
  14.     //phone();  
  15.     phone(double price = 15):product(price){cout << "phone" << endl;}  
  16.     ~phone(){cout << "~phone" << endl;}  
  17.     void call(){  
  18.         cout << "use calling" << endl;  
  19.     }  
  20. };  
  21.   
  22. class MP3:public product{  
  23. public:  
  24.     MP3(double price = 20):product(price){cout << "MP3" << endl;}  
  25.     ~MP3(){cout << "~MP3" << endl;}  
  26.     void play(){  
  27.         cout << "use to listening music" << endl;  
  28.     }  
  29. };   
  30.   
  31. class vedio:public product{  
  32. public:  
  33.     vedio(double price = 0):product(price){cout << "vedio" << endl;}  
  34.     ~vedio(){cout << "~vedio" << endl;}  
  35.     void vcd(){  
  36.         cout << "watch vedio" << endl;  
  37.     }   
  38. };  
  39. class iphone:public phone,public MP3,public vedio{  
  40.       
  41. };  
  42.   
  43. int main(){  
  44.     iphone iphone6;  
  45.     //cout << iphone6.getprice() << endl;同样会产生冲突的问题  
  46.     //cout << sizeof(iphone) << endl;  
  47.     cout << iphone6.MP3::getprice() << endl;  
  48.     cout << iphone6.phone::getprice() << endl;  
  49.     //cout << iphone6.getprice() << endl;//直接调用产生冲突问题，编译器不知道该调用哪一个  
  50. }  
上面的代码中，product的构造函数 被调用了三次，因为这种继承是一级一级的来的，构造子类的时候找父类，发现父类还有父类，就去调用爷爷类的构造函数，三次继承，三次调用。


这种继承方式构成了一种菱形或者钻石型的继承，叫做菱形继承或者钻石继承，但钻石继承并没有实际解决数据多次复制的问题，为了解决菱形继承，c++提出了虚继承。虚继承就是在继承的时候加上virtual关键字修饰即可。虚继承对于共同的成员父亲类从爷爷类那里继承来的，这里为double price，子类直接越级访问，直接从爷爷类那里继承price。

[cpp] view plain copy
  1. /*类中也会有对齐和补齐*/  
  2. #include <iostream>  
  3. using namespace std;  
  4. /*抽象到更高层的类中*/  
  5. class product{  
  6.     int price;  
  7. public:  
  8.     int  getprice(){  
  9.         return price;  
  10.     }  
  11.     product(double price = 0):price(price){cout << "product" << endl;}  
  12. };  
  13.   
  14. class phone:virtual public product{  
  15. public:  
  16.     //phone();  
  17.     phone(double price = 15):product(price){cout << "phone" << endl;}  
  18.     ~phone(){cout << "~phone" << endl;}  
  19.     void call(){  
  20.         cout << "use calling" << endl;  
  21.     }  
  22. };  
  23.   
  24. class MP3:virtual public product{  
  25. public:  
  26.     MP3(double price = 20):product(price){cout << "MP3" << endl;}  
  27.     ~MP3(){cout << "~MP3" << endl;}  
  28.     void play(){  
  29.         cout << "use to listening music" << endl;  
  30.     }  
  31. };   
  32.   
  33. class vedio:virtual public product{  
  34. public:  
  35.     vedio(double price = 0):product(price){cout << "vedio" << endl;}  
  36.     ~vedio(){cout << "~vedio" << endl;}  
  37.     void vcd(){  
  38.         cout << "watch vedio" << endl;  
  39.     }   
  40. };  
  41. class iphone:virtual public phone,virtual public MP3,virtual public vedio{  
  42. public:  
  43.     iphone(int m = 0,int v = 0,int p = 0):product(m + p + v){}  
  44. };  
  45. /*虚函数之后，product的构造函数只被调用了一次，孙子类直接越级访问 
  46. 了product类*/  
  47. int main(){  
  48.     iphone iphone6(1000,2041,3201);  
  49.     //cout << iphone6.getprice() << endl;同样会产生冲突的问题  
  50.     //cout << sizeof(iphone) << endl;  
  51.     //cout << iphone6.MP3::getprice() << endl;  
  52.     //cout << iphone6.phone::getprice() << endl;  
  53.     //cout << iphone6.getprice() << endl;直接调用产生冲突问题，编译器不知道该调用哪一个  
  54.     cout << sizeof(iphone) << endl;  
  55.     cout << iphone6.getprice() << endl;  
  56. }  

这个代码中product的构造函数只调用了一次，说明子类直接越级访问了爷爷类的数据。而对于父类特有的子类照常继承，只是没有通过父类去继承爷爷类的数据成员，所以product的构造函数只被调用了一次。


虚函数：在函数前面加上virtual关键字修饰过的就是虚函数.

#include <iostream>
using namespace std;
class A{
int x;
public:
virtual void show(){}
virtual void showa(){}
};
int main(){
cout << sizeof(A) << endl;
}

虚函数的主要表现为会占用四个字节的空间，只要成员中出现虚函数，不管有多少个虚函数，都只用四个字节来维护这个虚关系。虚函数会影响对象的大小。维护虚关系使用一个指针来维护的，所以是四个字节。


函数重写：

在父类中出现一个虚函数，如果在子类中提供和父类同名的函数（注意区分名字隐藏），这就加函数重写。

函数重写要求必须有相同函数名，相同的参数列表，相同的返回值。


三、c++面向对象之多态

1、多态：一个父类型的对象的指针或者引用指向或者是引用一个子类对象时，调用父类型中的虚函数，如果子类覆盖了虚函数，则调用的表现是子类覆盖之后的。

继承是构成多态的基础；

虚函数是构成多态的关键；

函数覆盖是构成多态的必备条件；

多态的应用：函数参数，函数返回值。

多态的产生必须依靠上面的四点，缺一不可。


2、多态的应用，多态相对做到了通用类型编程，主要用在函数参数和函数的返回值上。

[cpp] view plain copy
  1. /*多态的应用： 
  2. 1、函数参数 
  3. 2、函数返回值*/  
  4. #include <iostream>  
  5. using namespace std;  
  6. class Animal{  
  7. public:  
  8.     virtual void run(){  
  9.         cout <<"Ainimal run()"<<endl;  
  10.     }  
  11.     void show(){  
  12.         cout <<"Animal show()"<<endl;  
  13.     }  
  14. };  
  15.   
  16. class Dog:public Animal{  
  17. public:  
  18.     void run(){  
  19.         cout <<"Dog run()"<<endl;  
  20.     }  
  21.     void show(){  
  22.         cout <<"dog show()"<<endl;  
  23.     }  
  24. };  
  25.   
  26. class Cat:public Animal{  
  27. public:  
  28.     void run(){  
  29.         cout <<"cat run()"<<endl;  
  30.     }  
  31. };  
  32. /*多态用作函数参数*/  
  33. void showAnimal(Animal * animal){  
  34.     animal->show();  
  35.     animal->run();  
  36. }  
  37. /*多态用作返回值*/  
  38. Animal * getAnimal(int x){  
  39.     if (1 == x)  
  40.         return new Dog();  
  41.     if (2 == x)  
  42.         return new Cat();  
  43. }  
  44. int main(){  
  45.     Cat cat;  
  46.     showAnimal(&cat);  
  47.     Dog dog;  
  48.     showAnimal(&dog);  
  49. }  

3、多态的实现原理

多态的实现主要依赖于下面的三个东西：

虚函数：成员函数加了virtual修饰

虚函数表指针：一个类型有虚函数，则对这个类型提供一个指针，这个指针放在生成对象的前四个字节。同类型的对象共享一张虚函数表。并且不同类型的虚函数表地址不同。

虚函数表：虚函数表中的每个元素都是虚函数的地址。

一个类型一旦出现虚函数，则会生成一张虚函数表，虚函数表中存放的就是虚函数的函数地址，通过这个函数地址可以到代码区中去执行对应的函数。虚函数表中只存放类型中的虚函数，不是虚函数的一概不管。在每个生成的类型对象的前四个字节中存放的是虚函数表指针，通过这个指针可以访问到虚函数表，从而访问其中的函数。同种类型共享虚函数表，不同类型有自己独立的虚函数表，继承关系中的子类和父类属于不同类型，所以有自己独立的函数表。


[cpp] view plain copy
  1. /*多态的原理*/  
  2. #include <iostream>  
  3. #include <cstring>  
  4. using namespace std;  
  5. class Animal{  
  6.     int x;  
  7. public:  
  8.     virtual void fun(){  
  9.         cout<< "Aniaml fun()"<<endl;  
  10.     }  
  11.     virtual void run(){  
  12.         cout <<"Animal run()"<<endl;  
  13.     }  
  14.     void show(){  
  15.         cout <<"Animal show()"<<endl;  
  16.     }  
  17. };  
  18.   
  19. class Dog:public Animal{  
  20. public:  
  21.     virtual void fun(){  
  22.         cout << "dog run"<<endl;  
  23.     }  
  24.     void run(){  
  25.         cout <<"dog run"<<endl;  
  26.     }  
  27. };  
  28.   
  29. class Cat:public Animal{  
  30. public:  
  31.     void fun(){  
  32.         cout <<"cat fun"<<endl;  
  33.     }  
  34. };  
  35.   
  36. int main(){  
  37.     Animal a;  
  38.     Animal b;  
  39.     /*取出虚函数表的地址并打印*/  
  40.     int * pi = (int*)&a;  
  41.     cout <<showbase<< hex << *pi<<endl;  
  42.   
  43.     pi = reinterpret_cast<int*>(&b);  
  44.     cout <<showbase<< hex << *pi<<endl;  
  45.   
  46.     /*子类不会和父类共享虚函数表,地址不一样*/  
  47.     Dog dog;  
  48.     pi = reinterpret_cast<int*>(&dog);  
  49.     cout <<showbase<< hex << *pi<<endl;  
  50.   
  51.     Animal * pcat = new Cat();  
  52.     pcat->run();  
  53.     pcat->fun();  
  54.   
  55.     /*更改dog的虚表的值，我们把dog的虚表地址 
  56.     改成cat的虚表地址*/  
  57.     Animal * pdog = new Dog();  
  58.     pdog->run();  
  59.     pdog->fun();  
  60.   
  61.     /*更换dog的虚表地址,将cat的前四个字节 
  62.     移动到dog的前四个字节*/  
  63.     memcpy(pdog,pcat,4);  
  64.     pdog->run();  
  65.     pdog->fun();  
  66.     /*上面的更改后，狗变成了猫的特性*/  
  67. }  

上述程序对应的内存图：

C++ 三大特性 封装、继承和多态 详细总结

可以看出，一旦满足了多态的条件，程序自然按照上图的流程执行。

4、上面既然说了，虚函数表中存放的是函数的地址，那么能不能直接我们自己取出虚函数的地址，直接调用所需要的函数呢？

[cpp] view plain copy
  1. #include <iostream>  
  2. using namespace std;  
  3.   
  4. class Animal{  
  5. public:  
  6.     virtual void run(int x){  
  7.         cout <<"run x="<<x<<endl;  
  8.     }  
  9.     virtual void fun(int x){  
  10.         cout <<"fun x="<<x<<endl;  
  11.     }  
  12.     void show(){  
  13.         cout <<"this is show()"<<endl;  
  14.     }  
  15. };  
  16.   
  17.   
  18. int main()  
  19. {  
  20.     /*去掉函数名就是函数指针的类型，指针简化操作*/  
  21.     typedef void (*MFUN)(Animal* a,int x);/*MFUN就是虚表中的函数指针类型*/  
  22.   
  23.     typedef MFUN* VTABLE;//MFUN*就是虚表类型  
  24.   
  25.     Animal animal;  
  26.     VTABLE vt = *((VTABLE*)&animal);  
  27.     /*虚函数表表现为函数指针数组*/  
  28.     vt[0](&animal,100);  
  29.     vt[1](&animal,123);  
  30.     return 0;  
  31. }  

虚表中存放的就是虚函数的函数指针，可以理解为函数指针的数组，通过typedef将指针降级。


5，虚析构函数

virtual关键字只能修饰成员函数或者析构函数，其他的函数都不行。

当我们用new创建一个指向子类对象的父类指针时，例如Animal * animal = new Dog()时，其中Animal时父类，Dog是子类，并且delete animal时，其子类对象的析构函数不会被调用，只会调用父类的析构函数。所以就会遇到一个问题，如果子类对象有自己独立的堆内存时，这部分内存就无法释放。这时，我们只需要在父类的析构函数上用virtual修饰即可，子类析构函数就会被调用。

[cpp] view plain copy
  1. #include <iostream>  
  2. using namespace std;  
  3.   
  4. class Animal{  
  5. public:  
  6.     Animal(){  
  7.         cout <<"Animal()"<<endl;  
  8.     }  
  9.     virtual ~Animal(){  
  10.         cout <<"~Animal()"<<endl;  
  11.     }  
  12. };  
  13. class Dog:public Animal{  
  14. public:  
  15.     Dog(){  
  16.         cout <<"Dog()"<<endl;  
  17.     }  
  18.     ~Dog(){  
  19.         cout <<"~Dog()"<<endl;  
  20.     }  
  21. };  
  22. int main(){  
  23.     Animal * pa = new Dog();  
  24.     delete pa;  
  25.     /*子类析构函数的调用必然引发父类析构*/  
  26. }  

虚析构函数的应用场景：

当父类中有虚函数时，应该吧父类的析构函数定义成虚析构函数。

子类和父类中都有自己的堆内存分配时。

相关推荐