面向对象三大特性：封装继承和多态。封装在类和对象阶段我们已经学习过了，封装就是指不暴露底层实现细节在规范使用的前提下又方便了用户。本文将就继承这一特性展开讲解
什么是继承
继承这个词对我们来说应该不陌生，在现实生活中，你作为你父亲的继承者之一可以获得你父亲的财产，直接少奋斗N年。这里的继承也差不多是这个意思：在一个程序中有很多不同的类，但是这些类可能有共同的属性（成员变量或成员方法），为了避免多次对同样的成员方法和成员变量声明，C 就提出了继承。继承是类设计层次的代码复用。被继承的类就是父类或者基类，继承的类叫做子类或者派生类。
当两者之间的关系是
is a的关系时就可以使用继承，在上述用例中Person就是父类/基类，Student就是子类/派生类，在叫的时候最好搭配起来，不要叫基类和子类。 public是公有继承方式，继承方式和访问限定符一样有三个：public，protected，private
继承方式
类成员/继承方式 | public继承 | protected继承 | private继承 |
|---|---|---|---|
基类的public成员 | 派生类的public成员 | 派生类的protected 成员 | 派生类的private 成员 |
基类的protected 成员 | 派生类的protected 成员 | 派生类的protected 成员 | 派生类的private 成员 |
基类的private成员 | 在派生类中不可见 | 在派生类中不可见 | 在派生类中不可 |
父类的private成员在子类中是不可见的，不可见并不是因为没有被继承下来，只是不能被访问（除非使用共有函数） private和protected的主要区别就是在与继承，从有了继承以后我们说要尽量少用private（除非该成员是该类所特有的），因为继承的目的就是在于代码复用。 在实际当中一般使用的都是公有继承，其他两种方式很少用。 class定义的类默认继承是private，struct默认是public继承。但写明继承方式是一个好习惯
赋值规则
子类对象可以赋值给父类对象，父类的指针，父类的引用，并且中间没有临时变量的产生，这种赋值方式被称为切片/切割。（只能子类赋值给父类，而不能将父类赋值给子类，因为子类中有父类的那一块，但是父类中没有子类特有的成员。）
切片仅限公有继承，因为如果是保活或者私有继承，父类中的成员权限在子类中改变了。
继承中的作用域（隐藏）
父类和子类都有各自独立的类域，如果它们有同名的成员函数（不是继承下来的），就会产生隐藏。所谓隐藏就是对在子类中只能看到子类自己定义的函数，在父类中也是一样。为什么不是函数重载？（函数重载要求在同一个作用域下）
代码语言：javascript复制class Parent
{
public:
void test(double i)
{
cout << "you can not see me"<<i << endl;
}
protected:
int _a;
};
class Child:public Parent
{
public:
void test(int a)
{
cout << "这是一个隐藏示例" <<_a<< endl;
}
private:
int _b;
};
int main()
{
Child b;
b.test(1.1);
return 0;
}
可以看到即使我传一个浮点数，也只能调用到子类中的test函数，因为b是一个子类对象。
当然你需要通过子类对象调用父类的test函数也是可以的，因为子类继承了父类的test函数，只是被隐藏了，只要加上作用域限定符就可以调到父类的test函数：
不但同名的函数会隐藏，同名的成员变量也是会隐藏的
代码语言：javascript复制class Child:public Parent
{
public:
void test()
{
cout << "这是一个隐藏示例" <<_a<< endl;
}
private:
int _a = 3;
int _b;
};
如果子类中存在与父类同名的成员函数，会默认将父类的函数隐藏，除非使用域访问限定符指明类域访问。 父类和子类的析构函数也会构成隐藏，因为底层将析构函数统一处理成了destructor函数 父类和子类中不要定义同名的成员，因为这本身也容易让人混淆
子类中的默认成员函数
继承的子类与普通类不同的地方在于，子类中还有父类中的那一部分。
构造函数和析构函数：对于内置类型不做处理，对于自定义类型调用它的构造和析构 拷贝构造和赋值重载：对于内置类型按字节拷贝，对于自定义类型调用它的拷贝构造和赋值重载
子类中父类的那一部分，要调用父类的默认成员函数来处理。
代码语言：javascript复制class Child:public Parent
{
public:
Child(int y)
:Parent(_a)
,_b(y)
{}
Child(const Child& c)
:Parent(c)//直接在初始化列表处传子类对象调用父类拷贝构造即可（切片）
, _b(c._b)
{}
Child& operator=(const Child& d)
{
if (this != &d)
{
Parent::operator=(d);//这里必须要指明类域，否则会因为隐藏的原因造成死循环
_b = d._b;
}
return *this;
}
private:
int _b;
};但是析构函数是一个例外，我们不能显示的调用父类的析构函数：
代码语言：javascript复制class Parent
{
public:
Parent(int x)
:_a(x)
{}
~Parent()
{
cout << "~Person" << endl;
}
protected:
int _a;
};
class Child:public Parent
{
public:
Child(int y)
:Parent(_a)
,_b(y)
{}
~Child()
{
Parent::~Parent();//前面有提到过：析构函数默认是隐藏，要调用父类的析构要指明类域
cout << "~Child" << endl;
}
private:
int _b;
};
这里父类的析构被调用了两次，因为这里没有清理资源否则是会报错的。
父类的析构不用我们调用，在子类的析构结束时编译器会自动调用父类的析构，这里我们可以通过汇编来看一下：
需要自己写默认成员函数的情况
1.父类没有默认构造函数，需要自己显示写构造
2.子类存在浅拷贝，需要自己写赋值重载和拷贝构造
3.子类存在资源要释放，需要显示写析构函数
继承与友元及静态成员
1.友元关系不能被继承
2.静态成员虽然可以被继承，但是因为静态成员放在公共代码段，所以子类和父类共享静态的成员
多继承
一个子类继承一个父类是单继承，如果一个子类继承多个父类就是多继承。多继承本身没有错，因为一个类继承多个类也是一件很合理的事情。但是多继承给了别人犯错的机会，这个犯错就是菱形继承
菱形继承
可以看到这个继承关系就像一个菱形一样，所以就叫菱形继承
菱形继承的问题
因为Student和Teacher都是Person的子类，也就是说这两个类中都有一份Person的成员变量；而Assistant作为这两个类的共同子类，也就继承了两份Person的成员，这会有数据冗余的问题，此外还会导致调用时的二义性（不知道你是要调用Student类中的Person成员，还是Teacher类中的Person成员）。
void Test()
{
// 这样会有二义性无法明确知道访问的是哪一个
Assistant a;
a._name = "peter";
// 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
a.Student::_name = "xxx";
a.Teacher::_name = "yyy";
}下面通过内存窗口来看一下菱形继承的内存结构：
代码语言：javascript复制class A
{
public:
int _a;
};
class B :public A
{
public:
int _b;
};
class C :public A
{
public:
int _c;
};
class D :public B, public C
{
public:
int _d;
};
int main()
{
D d;
d._b = 1;
d._d = 2;
d.B::_a = 3;
d.C::_a =4;
return 0;
}
菱形虚拟继承
存在数据冗余和二义性问题的根本原因就是同样的一份Person成员数据在Assistant中存在了两份，只要在继承的时候加上virtual关键字就可以解决这个问题。下面通过内存窗口来看一下菱形虚拟继承的内存结构：
class A
{
public:
int _a;
};
class B :virtual public A
{
public:
int _b;
};
class C :virtual public A
{
public:
int _c;
};
class D :public B, public C
{
public:
int _d;
};
使用虚拟继承以后，_a只存在一份，这也就没有了二义性的问题，但是继承于B类和C类的_b和_c上方多了一串地址，再次要通过内存查找这串地址，发现这串地址之后的位置存放一个数字0x14，这个数字就是继承于B的成员到_a的偏移量，通过这个偏移量，对象d便能到d.B::_a。这样就解决了菱形继承成员冗余的问题。
此时A被称为虚基类，继承的B和C类要找到A中的成员，就要通过虚基表中的偏移量来计算。
在实际使用的时候，不要设计菱形继承，因为这是C 的一个大坑，跳进去就基本上爬不出来了哦。
继承和组合
继承是一个is a的关系，也就是说每一个子类都是一个父类；组合是has a的关系，也就说每一个B类中都有一个A类对象。下面是一个组合示例：
// Car和BMW Car和Benz构成is-a的关系
class Car
{
protected:
string _colour = "白色"; // 颜色
string _num = "陕ABIT00"; // 车牌号
};
class BMW : public Car
{
public:
void Drive() {cout << "好开-操控" << endl;}
};
class Benz : public Car
{
public:
void Drive() {cout << "好坐-舒适" << endl;}
};
// Tire和Car构成has-a的关系
class Tire
{
protected:
string _brand = "Michelin"; // 品牌
size_t _size = 17; // 尺寸
};
class Car
{
protected:
string _colour = "白色"; // 颜色
string _num = "陕ABIT00"; // 车牌号
Tire _t; // 轮胎
};继承是一种白盒复用，子类对父类的实现细节可见，而且父类和子类的耦合性高，一旦父类做了修改就可能影响到子类的正常使用；组合是一种黑盒复用，无法窥探其内部实现的细节，且组合的耦合度低，只有Car的公有成员被修改才会影响到BMW的使用。
如果一个类既是is a的关系又是has a的关系，优先使用组合。
