首先我们应该知道C++的三大特性就是封装、继承和多态。
此篇文章将详细的讲解继承的作用和使用方法。
- 继承
一个类,继承另一个已有的类,创建的过程
父类(基类)派生出子类(派生类)的过程
继承提高了代码的复用性
【1】继承的格式
class 类名:父类名`
`{};
【2】继承的权限
class 类名:继承的权限 父类名`
`{};`
`如果不写继承方式,默认是私有继承
父类中的权限 public|private|protected public|private|protected public|private|protected `
`继承方式 public private protected`
`子类中的权限 public|不能访问|protected private|不能访问|private protected|不能访问|protected`
`
【3】继承时类中的特殊成员函数
特殊的成员函数不会被继承
构造函数:
- 需要在子类中显性调用父类的构造函数(初始化列表中)(透传构造)
- 透传构造
- 继承构造
- 委托构造
需要在子类中显性调用父类构造函数的场合:
父类中只有有参构造 ----->子类在创建类对象时,必须手动调用父类的构造函数
#include <iostream>`
`using` `namespace` `std;`
`class` `Father`
`{`
`public:`
`int age;`
`char c;`
`Father(int a,char c):age(a),c(c){cout <<` `"Father有参"` `<< endl;}`
`};`
`class` `Child:public Father //----->私有继承`
`{`
`int high;`
`public:`
`void` `show()`
`{`
` cout << c << endl;`
`}`
`};`
`int` `main()`
`{`
`//Child c1; //error,因为父类只有有参构造,而子类中没有提供能够调用父类有参构造的构造函数,不能成功创建父类的空间`
`//Father f1;`
` c1.age;`
` cout <<` `sizeof` `(Father)` `<< endl;`
` cout <<` `sizeof` `(Child)` `<< endl;`
`return` `0;`
`}
i)透传构造
在子类构造函数的初始化列表中,显性调用父类的构造函数
ii)继承构造
C++支持
不用在子类中再写一遍父类的构造函数
使用:using Father::Father; ----->在子类中使用父类的构造函数
直接使用继承构造的方式,不能对子类成员初始化
继承构造本质上并不是把父类中的构造函数继承给子类,编译器自动根据父类中构造函数的格式,提供出派生的构造函数(个数和参数都和父类中的构造函数一致),主要还是通过透传构造创建父类的空间
#include <iostream>`
`using` `namespace std;`
`class` `Father`
`{`
`public:`
`int age;`
`char c;`
`// Father(){cout << "Father无参" << endl;}`
`Father(int a,char c):age(a),c(c){cout <<` `"Father有参两个参数"` `<< endl;}`
`Father(char c):c(c){cout <<` `"Father有参一个参数的"` `<< endl;}`
`Father(Father &other):age(other.age),c(other.c)`
`{cout <<` `"Father拷贝"` `<< endl;}`
`};`
`class` `Child:public Father //----->私有继承`
`{`
`private:`
`int high;`
`//父类中的public成员age,通过公有继承,仍然是public`
`using Father::age;` `//把父类中公有继承下来的age成员,在子类中改成私有权限`
`public:`
`void` `show()`
`{`
` cout << c << endl;`
`}`
`//子类的无参构造,但是显性调用父类的有参构造还给了默认值`
`//透传构造`
`// Child():Father(12,'a'){cout << "Child无参构造" << endl;}`
`// Child(int a,char c,int h):Father(a,c),high(h)`
`// {cout << "Child有参构造" << endl;}`
`//父类中的所有构造函数,都被继承到了子类中`
`using Father::Father;` `//更高效一些`
`};`
`int` `main()`
`{`
` Child c1(10);`
` Child c2(20,'z');`
` Child c3 = c2;`
`//Father f1;`
`//c1.age;`
` cout <<` `sizeof` `(Father)` `<< endl;`
` cout <<` `sizeof` `(Child)` `<< endl;`
`return` `0;`
`}`
`
iii)委托构造
一个类的情况,并不直接通过无参构造实例化对象,而是无参构造委托了有参构造,实例化对象
继承时的情况
Child():Child(10){cout << "Child无参构造" << endl;} //Child c1`
` Child(int a):Father(12,'a'),high(a)`
` {cout << "Child有参构造一个参数" << endl;}
iv)拷贝构造
需要在初始化列表中显性调用父类的拷贝构造,传other对象到父类的拷贝构造中
Father(Father &other):age(other.age),c(other.c){cout << "Father的拷贝构造" << endl;}`
`Child(Child &other):Father(other),high(other.high){}
【4】继承时构造和析构的时机
继承关系,可以理解为包含关系
子类在继承父类时,会把父类中的成员保留一份,再来创建子类自己的成员
父类先构造,子类后构造
子类先析构,父类后析构
#include <iostream>`
`using` `namespace std;`
`class` `F`
`{`
`int` `*p;`
`public:`
`F():p(new` `int){cout <<` `"F无参构造"` `<< endl;}`
`~F()`
`{`
`delete p;`
` cout <<` `"F析构函数"` `<< endl;`
`}`
`};`
`class` `C:public F`
`{`
`int` `*p;`
`public:`
`C():p(new` `int){cout <<` `"C无参构造"` `<< endl;}`
`~C()`
`{`
`delete p;`
` cout <<` `"C析构函数"` `<< endl;`
`}`
`};`
`int` `main()`
`{`
` C *p1 =` `new C;`
`delete p1;` `//空间释放时,会自动调用析构函数,无需手动调用`
` p1 =` `nullptr;`
`return` `0;`
`}`
`
【5】父子类中存在同名成员问题
访问时不会发生冲突,默认访问子类的
#include <iostream>`
`using` `namespace std;`
`class` `F`
`{`
`public:`
`int` `*p;`
`F():p(new` `int){cout <<` `"F无参构造"` `<< endl;}`
`~F()`
`{`
`delete p;`
` cout <<` `"F析构函数"` `<< endl;`
`}`
`};`
`class` `C:public F`
`{`
`public:`
`int` `*p;`
`C():p(new` `int){cout <<` `"C无参构造"` `<< endl;}`
`~C()`
`{`
`delete p;`
` cout <<` `"C析构函数"` `<< endl;`
`}`
`};`
`int` `main()`
`{`
` C *p1 =` `new C;`
`*(p1->p)` `=` `90;`
` cout <<` `*(p1->p)` `<< endl;` `//子类成员和父类成员同名,默认优先访问子类成员`
` cout <<` `*(p1->F::p)` `<< endl;` `//通过域限定符访问父类的成员`
`delete p1;` `//空间释放时,会自动调用析构函数,无需手动调用`
` p1 =` `nullptr;`
`return` `0;`
`}
- 多重继承
一个子类,继承自多个基类
【1】格式
class 类名:继承权限 父类名,继承权限 父类名····`
`{}
【2】当多个父类中包含同名成员
多个父类中包含同名成员,通过域限定符访问指定的父类中成员
#include <iostream>`
`using` `namespace std;`
`class` `Room`
`{`
`public:`
`void` `clean()`
`{`
` cout <<` `"打扫房间"` `<< endl;`
`}`
`};`
`class` `BedRoom`
`{`
`public:`
`void` `play()`
`{`
` cout <<` `"可以玩游戏"` `<< endl;`
`}`
`void` `clean()`
`{`
` cout <<` `"打扫卧室"` `<< endl;`
`}`
`};`
`//Home类公共继承字Room和BedRoom类`
`class` `Home:public Room,public BedRoom`
`{`
`};`
`int` `main()`
`{`
` Home h1;`
` h1.play();`
` h1.Room::clean();`
` h1.BedRoom::clean();`
`return` `0;`
`}
- 菱形继承(钻石继承)
【1】格式
A ----->公共基类`
`/ \`
` B C ------>中间子类`
` \ /`
` D ------>汇集子类
汇集子类中,会包含两份公共基类中的内容
【2】菱形继承存在的问题
- 会发生二义性的问题(同一个变量或者函数,可以通过两种方法访问)
- 如果公共基类,过大,会造成汇集子类中的代码膨胀/冗余
#include <iostream>`
`using` `namespace std;`
`class` `A`
`{`
`public:`
`int a;`
`//A(int a):a(a){cout << "A" << endl;}`
`};`
`class` `B:public A`
`{`
`public:`
`int c;`
`//B(int a,int c):A(a),c(c){cout << "B" << endl;}`
`};`
`class` `C:public A`
`{`
`public:`
`//C(int a):A(a){cout << "C" << endl;}`
`};`
`class` `D:public C,public B`
`{`
`public:`
`//D(int a,int c):B(a,c),C(a),A(a){cout << "D" << endl;}`
`};`
`int` `main()`
`{`
` D d1;`
` d1.B::a =` `90;` `//二义性,还可以直接通过中间子类访问,直接访问B中的a成员`
`//cout << d1.C::A::a << endl; //会发生二义性,因为访问A,但是有两条路径都访问到A`
`return` `0;`
`}
【3】虚继承(virtual)
虚继承指对公共基类的虚继承。
主要用于解决菱形继承问题,
采用虚继承后,公共基类中的内容,只会在汇集子类中存在一份,在汇集子类中,可以通过任意一条路径访问到公共基类中的成员
#include <iostream>`
`using` `namespace std;`
`class` `A`
`{`
`public:`
`int a;`
`};`
`class` `B:virtual public A`
`{`
`public:`
`int c;`
`};`
`class` `C:virtual public A`
`{`
`};`
`class` `D:public B,public C`
`{`
`};`
`int` `main()`
`{`
` D d1;`
` d1.B::A::a =` `90;`
` cout << d1.C::A::a << endl;`
`return` `0;`
`}`
`