一、基类和派生类

一个类可以派生出另一个类，前者称为基类或者父类，或者称为派生类或者子类，一个派生类可以从一个基类派生，也可以从多个基类派生。前者称为单继承，后者称为多继承。

单继承定义格式如下：

class 派生类：继承方式 基类
{派生类新定义的成员；
}；

继承方式有如下三种：public private protected
分别是公有继承 私有继承 保护继承

多继承定义格式如下：

class 派生类：继承方式一 基类一，继承方式二 基类二....
{派生类新定义成员;
};

派生类的三种定义方式
(1)公有继承
公有继承：public, 基类的public和protected成员的访问属性在派生类保持不变，而基类的private成员不可访问，也就是基类的public和protected成员分别作为派生类的public 和protected成员，派生类的其他成员可以直接访问他们。

(2)保护继承
保护继承：protected, **基类的public和protected成员可以被继承到派生类中，但是访问属性都变为protected,**而基类的private成员同样不能被访问，即基类的public 以及 protected成员被作为protetcted成员,派生类的其他成员可以直接访问他们。所以子类的对象不能直接而访问基类的继承下来的成员。如果要访问继承下来的成员，必须要通过成员函数、友元函数来访问。

(3)私有继承
当派生类的继承方式是private时，**基类的public和protected成员可以被继承到派生类中，但是访问属性都变为private属性，**基类的private成员不能访问，即基类的public和protected成员都作为派生类的private成员。如果要访问继承下来的成员，必须要通过成员函数、友元函数来访问。

二、单继承

1.成员访问权限的控制

#include<iostream>
using namespace std;class A
{public:void f1();A(){i1 = 10;j1 = 11;}protected:int j1;private:int i1;
};class B:public A
{public:void f2();B(){i2 = 20;j2 = 21;}protected:int j2;private:int i2;
};class C:public B
{public:void f3();C(){i3 = 30;j3 = 31;}protected:int j3;private:int i3;
};

派生类B的成员函数f2()可以直接访问基类A中的成员f1() j1 但是不能访问i1
派生类B的对象b可以直接访问基类A的成员f1() 但是不能直接访问i1 j1
派生类C的成员函数可以直接访问基类B的成员f2() j2 但是不能直接访问i2 也可以间接访问基类A的成员f1() j1 不能间接访问i1
派生类C的对象c可以直接访问基类B的f1()以及见解基类A的f1(),其他的店铺不能访问

总之，公有继承，派生类的成员函数可以直接访问基类的公有成员还有保护成员；派生类的对象仅仅可以访问基类中的公有成员

2. 单继承中构造函数的设计及其执行过程
构造函数不能被继承，因此，派生类的构造函数必须通过调用基类的构造函数来初始化基类子对象，所以，在定义派生类的构造函数同时，除了对自己的数据成员进行初始化外，还必须负责调用基类构造函数时基类的数据成员得以初始化。

派生类的构造函数一般格式如下：

派生类名（派生类构造函数总参数表）：基类构造函数（参数表1），子对象名（参数表2）
{派生类的数据成员初始化；
}；

派生类的构造函数调用顺序如下：
基类的构造函数
子对象类的构造函数（如果有的话）
派生类构造函数

#include<iostream>
using namespace std;class A
{public:A(){cout<<"A Constructor"<<endl;}
};class B:public A
{public:B(){cout<<"B Constructor"<<endl;}
};int main(void)
{B b;system("pause");return 0;
}

运行结果

先执行A的构造函数，在执行B的构造函数。

3. 单继承中析构函数的执行过程
析构函数不能被继承，先执行派生类的析构函数，再执行基类的析构函数，也就是与构造函数的执行顺序正好相反。

在实际应用中，使用派生类构造函数应该注意如下几个问题：
1. 派生类构造函数定义可以省略对基类构造函数的调用，其条件是基类中必须有默认的构造函数或者根本没有定义构造函数。
2. 当基类的构造函数使用一个或者多个参数时，派生类必须定义构造函数，提供将参数传递给基类构造函数的途径

4. 将派生类对象转换为基类对象
Public 继承 ，由于派生类具有对应的每个基类的相应成员（派生类的成员通常比基类的成员多），所以派生类的对象赋给基类对象是合理的，但是反过来不行，因为派生类具有基类不具有的成员定义。派生类可以赋值给基类对象。派生类对象也是基类对象，所以指向派生类对象的指针也可以隐式转换为指向基类对象的指针。

搭配方式：
直接用基类指针引用基类对象
直接用派生类指针引用派生类对象
用基类指针引用一个派生类对象。只能引用基类成员
用派生类指针引用基类的对象，这种方法错误，派生类指针必须先转化为基类指针

#include<iostream>
using namespace std;class A
{private:int a;public:void setA(int X){a = X;}void dispa(){cout<<"a  = "<<a << endl;}
};class B:public A
{private:int b;public:void setB(int Y){b = Y;}void dispb(){cout<<"b = "<<b<<endl;}
};int main(void)
{A *pa = new A();pa->setA(1);pa->dispa();B *pb = new B();pb->setB(2);pb->dispb();A *pc = new B();//子类对象赋给基类 这是允许的pc->setA(3);pc->dispa();B *pd = new B();A obj;obj.setA(4);pd = (B *)&obj;pd->dispa();system("pause");return 0;
}

三、多继承

class C:public A,public B

1. 多继承中构造函数的设计以及执行过程
多继承有个总的参数表 每个基类有分的参数表，所以，派生类的参数个数必须包含所有的基类参数个数

派生类构造函数执行顺序如下：
1. 调用基类的构造函数，调用次序从左到右
2. 调用子对象的构造函数 从左到右
3. 调用派生类的构造函数

#include<iostream>
using namespace std;class A
{private:int a;public:A(int i){a = i;cout<<"A Constructor"<<endl;}void Disp(){cout<<"A = "<<a<<endl;}
};class B
{private:int b;public:B(int i){b = i;cout<<"B Constructor"<<endl;}void Disp(){cout<<"B = "<<b<<endl;}
};class C:public A,public B
{private:int c;public:C(int k):A(k - 2),B(k + 3)   //包含基类成员的初始化列表 构造函数 先初始化基类 在初始化派生类{c = k;cout<<"C Constructor"<<endl;}void disp(){A::Disp();//调用基类的成员函数B::Disp();cout<<"c = "<<c<<endl;}
};int main(void)
{C obj(10);obj.disp();system("pause");return 0;
}

2. 多继承中的析构函数执行过程
执行顺序与构造函数正好相反

3. 二义性问题
上方面的代码中，派生类C的两个基类都含有disp()函数，但是到底访问哪一个基类的成员函数，这就出现了二义性问题，所以用：：作用域运算符进行限定