C++是一种面向对象的语言，而面向对象，有着三大特征——封装，继承，多态。
关于封装，在我的其它博客中已经有过简单的介绍了。这里我将简单叙述一下面向对象的三大特征之二——继承。
目录
什么是继承
继承的定义格式
定义格式
继承方式
基类与派生类对象的赋值转换
继承中的作用域
同名隐藏
继承下的默认成员函数
继承与友元
继承与静态成员
单继承与多继承
菱形继承
继承机制是面向对象程序设计中，使代码复用的最重要手段，它允许设计者在保持原有类的特性的基础上进行扩展，增加功能。
通过这种方法产生的新的类，被称为派生类；被继承的类。则称为派生类的基类。
继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。
继承是类设计层次的复用。
class [派生类] : [继承方式] [基类]与Java中的继承不同，C++中的继承有着三种继承方式，与C++的三种访问限定符一一对应。
| 基类成员/继承方式 | public继承 | protected继承 | private继承 |
| public成员 | public | protected | private |
| protected成员 | protected | protected | private |
| private成员 | 派生类中不可见 | ||
1.基类中的private成员无论以什么方式继承，在派生类中都是不可见的。所谓的不可见并不是指它没有被继承到派生类之中，基类的私有成员也会被继承到派生类之中，但是在语法上限制派生类对象不管实在类里还是类外都无法访问它。
2.保护成员限定符是由于继承才出现的。由于基类的private成员在派生类中不可被访问，所以如果某一个成员我们既需要在派生类中访问它，又要防止它在类外被访问，我们可以将它的访问权限定义为protected。
3.与成员变量的访问权限声明一样，类继承时也可以忽略对继承方式的指明。同样的，如果派生类使用的是class，默认继承方式为private；如果派生类使用的是struct，默认继承方式为public。
PS.在实际应用中，很少使用 protected / private 继承，一般都是使用 public 继承。因为 protected / private 继承的成员只能在派生类的类中使用，这导致实际应用中的拓展维护性不强。
要了解C++中基类与派生类对象的赋值转换，我们首先要了解在继承的条件下，基类与派生类的成员是如何存储的：
首先，我们假设一个类A，类A是类B的基类，即类B是类A的派生类。
类A中，有着 a1、a2、a3三个变量；类B中，除继承自A的三个成员变量外，还有b1、b2两个成员变量。
这些变量在内存中的存储大致如上图所示。通过程序验证如下：
基类与派生类对象的赋值转换，即赋值兼容规则，一定是在public的继承方式下才满足的。
通过公有继承，派生类就完全继承了基类的所有功能，包括其成员的访问属性，也就可以通过赋值兼容规则进行一系列操作。否则，由于基类成员在派生类中访问属性的改变，编译器会产生如下报错：
派生类对象可以赋值给基类的对象 / 基类的指针 / 基类的引用。
派生类从基类处继承了基类的所有成员变量，并且继承自基类的成员变量存储在整个子类对象所占的存储空间的前端。将子类（派生类）对象赋值给父类（基类）的对象 或 指针 或 引用，简单来看就像是将子类前部继承自父类的那部分切下来拷贝给父类。
基类对象不能赋值给派生类的对象。
这一点是非常好理解的，派生类对象往往会比基类对象多一些成员，如若将基类对象赋值给派生类对象，派生类中总会有成员无法被初始化。难道要调用一部分的构造函数？这显然是不行的。
基类的指针可以通过强制类型转换赋值给派生类的指针。但是必须是基类的指针指向派生类的对象的时候才是安全的。
基类指针指向派生类对象，是实现多态的途径之一。通过函数覆盖与虚函数，基类指针指向不同的对象，函数实现的功能也会不同。但这种操作往往会有很大的风险，所以在有可替代方法存在的情况下最好不要进行这类强制类型转换。
继承体系中基类与派生类都有独立的作用域。
正是由于基类与子类隶属于不同的作用域，所以子类与父类中有同名成员时，它们并不会构成函数重载，因为函数重载的前提是在同一作用域。
在继承体系中，也即在不同作用域的情况下，子类成员会屏蔽父类成员对同名成员的直接访问，这种情况被叫做隐藏，也称为重定义。
对于类成员的重定义，还有着如下细节：
成员变量隐藏：与成员变量类型无关，只与成员变量名是否相同有关
成员函数隐藏：与函数参数列表无关，只与成员函数名是否相同有关
PS.在子类成员函数中，可以使用如下方式显式访问基类成员：
基类 :: 基类成员实际上上述的一系列隐藏关系就是所谓的同名隐藏，不过这个概念还是单列出来再具体地讲一下比较好，内容不多且重复。
如果成员变量同名，子类对象直接访问同名成员变量时，优先访问自己的，与变量的类型是否相同无关。基类同名成员无法通过子类对象直接访问。
如果成员函数同名，子类对象直接访问同名成员函数时，优先访问自己的，与变量的类型是否相同无关。基类同名成员无法通过子类对象直接访问。
class A {
protected:
int a1;
int a2;
public:
A()
:a1(10)
,a2(20)
{}
void f() {
cout << "A" << endl;
}
void printA() {
cout << "a1 = " << a1 << endl;
cout << "a2 = " << a2 << endl;
}
};
class B : public A {
int a1;
int b1;
public:
B()
:a1(100)
,b1(200)
{}
void f() {
cout << "B" << endl;
}
void printB() {
cout << "a1 = " << a1 << endl;
cout << "b1 = " << b1 << endl;
cout << "A::a1 = " << A::a1 << endl;
}
};
int main() {
A a;
B b;
a.printA();
b.printB();
return 0;
}
可以看到，当我们直接访问派生类中的成员变量时，派生类默认访问的是其自身所定义的同名成员变量，只有当我们在访问时加上作用域限定符，才会精确地访问到基类中的同名成员变量。
int main() {
B b;
b.f();
b.A::f();
return 0;
}
同名成员函数同理。
当然，这里还是有着一定的小缺陷的。我们并没有涉及到上述的不同变量类型以及不同参数列表情况下的同名成员也会隐藏，但这并不是很难验证的事情。
我们讲过，C++中的类在创建时会，如果用户不显式定义，会生成六个默认成员函数。
分别是：
用于构造与清理的：
构造函数
析构函数
用于拷贝复制的：
拷贝构造函数
赋值运算符重载
对取地址运算符的重载：
取地址运算符重载const取地址运算符重载
而派生类既然是类，自然也有上述六种默认成员函数，同时，由于其隶属于继承体系，它的六种拷贝构造函数自然与平常情况下的默认成员函数略有不同。
在派生类中，其默认成员函数的生成与基类的默认成员函数息息相关，大致可总结如下：
1.派生类的构造函数必须调用基类构造函数初始化派生类中继承自基类的一部分。如果基类中没有默认构造函数，那么派生类中必须在初始化列表处显式调用。
class A {
protected:
int _a;
public:
A(int a) :_a(a) {}
};
class B : public A{
public:
int _b;
};
int main() {
B b;
return 0;
}
由上，可见，在继承体系下，当编译器发现基类没有默认构造函数时，会自动将为派生类构建的默认构造函数删除，从而导致了尝试调用已删除函数的报错。
2.派生类的拷贝构造函数必须调用基类的拷贝构造函数完成基类的拷贝初始化。
3.派生类的赋值运算符重载必须调用基类的赋值运算符重载。
4.派生类的析构函数在调用完成后会自动调用基类的析构函数清理基类成员。这样可以保证派生类先清理派生类成员再清理基类成员的顺序。
5.派生类对象初始化，先调用基类构造在调用派生类构造；派生类对象清理与之相反，先调用派生类析构再调用基类析构。
using namespace std;
class A {
public:
A() {
cout << "create A" << endl;
}
~A() {
cout << "destory A" << endl;
}
};
class B : public A{
public:
B() {
cout << "create B" << endl;
}
~B() {
cout << "destory B" << endl;
}
};
int main() {
B b;
return 0;
}
可见，与一般的类对象的创建相同，先构造的后析构。
在继承体系下，友元关系不能继承，即基类的友元并不能访问子类的私有及保护成员。
类的静态成员只是声明于类中，其存储并不与类的对象在同一片区域。类的静态成员保存于静态存储区。与类的对象多少无关，静态成员只存在一份。
在继承体系下，基类定义了static成员，则整个继承体系只存在一个这样的成员，即所有子类只有这一个成员。
class A {
public:
static int a;
};
class B : public A{
public:
void print() {
cout << "B::a = " << a << endl;
}
};
class C : public A {
public:
void print() {
cout << "C::a = " << a << endl;
}
};
int A::a = 0;
int main() {
A a1;
B b1;
C c1;
b1.print();
c1.print();
a1.a++;
b1.print();
c1.print();
return 0;
}
单继承：一个子类只有一个直接父类时，该关系称为单继承。
单继承就像是我们生物学的生物分类， 界、门、纲、目、科、属、种，每一级分类下的生物都有着一些相同的“特性”，然后根据剩余“特性”的不同，又细致地划分到更下一级，更细致的类之中。
| 界 | 动物界 | class Animalia |
| 门 | 脊索动物门 | class Chordata : public Animalia |
| 亚门 | 脊椎动物亚门 | class Vertebrata : public Chordata |
| 纲 | 哺乳纲 | class Mammalia : public Vertebrata |
| 亚纲 | 真兽亚纲 | class Eutheria : public Mammalia |
| 目 | 灵长目 | class Primates : public Eutheria |
| 科 | 人科 | class Hominidae : public Primates |
| 属 | 人属 | class Homo : public Hominidae |
| 种 | 智人种 | class Homo_sapiens : public Homo |
多继承：一个子类拥有两个或以上直接父类时称这个关系为多继承。
相比而言，多继承可能并不像单继承那样条理清晰。如果要做一个比喻的话，它更像我们从社会角度去看一个人。 恰如一个人可以有许多不同的身份，不同的职业。
在多继承种，一个派生类拥有多个基类，不同的基类按照其继承时声明的顺序在派生类对象种依次存储。
可以通过自己编写一些简单的代码，通过查看监视证明。
菱形继承是一种特殊的多继承。我们可以简单而形象地将其描述为——殊途同归。
可见，派生类assitant同时继承自student以及engineer两个基类，而这两个基类又都继承自同一个基类people。这种向上追溯导致同一个类的成员被重复继承的现象被称为菱形继承。
结合之前所讲述的继承体系下派生类成员在内存中的存储，我们不难发现，在菱形继承的情况下会导致一些来自父类的成员重复出现在派生类之中。
class A {
public:
int a1;
};
class B1 :public A {
public:
int b1;
};
class B2 : public A {
public:
int b2;
};
class C : public B1, public B2 {
public:
int c1;
};
int main() {
C c;
c.a1 = 1;
//c.B1::a1 = 1;
//c.B2::a1 = 2;
return 0;
}在我们直接访问有菱形继承带来的冗余部分时，编译器会报错并告知我们a1并不明确。
当然，我们时可以如被注释掉的地方一般，通过指明具体的作用域来访问到具体来自于哪个父类的成员，但是，这样只是解决了访问成员不明确的问题，却没有涉及到如和解决那部分冗余的数据。
对此，C++提供了虚拟继承用以解决菱形继承的二义性以及数据冗余问题。
class 派生类名:virtual [继承方式] 基类名1，virtual [继承方式] 基类名2,…{
派生类成员声明与定义;
};