继承机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，而继承是类设计层次的复用，所以继承的本质还是复用。
举例如下：
如下图所示，Person是父类，也称作基类。Teacher是子类，也称作派生类。
继承方式和访问限定符两两为一组，3*3一共有9种继承结果，如下图所示：
| 类成员 / 继承方式 | public继承 | protected继承 | private继承 |
|---|---|---|---|
| 基类的public成员 | 派生类的public成员 | 派生类的protected成员 | 派生类的private成员 |
| 基类的protected成员 | 派生类的protected成员 | 派生类的protected成员 | 派生类的private成员 |
| 基类的private成员 | 在派生类中不可见 | 在派生类中不可见 | 在派生类中不可见 |
所以有两种方式去理解继承方式的语法：
一种为基类的私有成员，一种不是基类的私有成员。
1、基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。
2、基类的私有成员在子类都是不可见。除了基类的基类的私有成员，基类其他成员在子类的访问方式为：Min(成员在基类的访问限定符，继承方式) 取它们两个的范围最小值。
注意：
1、保护和私有在父类中没有区别，区别体现在子类中，继承基类的private成员不可见，继承基类的protected是可见的。（可以看出保护成员限定符是因继承才出现的）。
2、使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。
派生类对象 可以赋值给 基类的对象 / 基类的指针 / 基类的引用。这里有个形象的说法叫切片或者切割。意思是把派生类中父类那部分切来赋值过去。
代码举例如下：
class Person
{
protected:
string _name; // 姓名
string _sex; // 性别
int _age; // 年龄
};
class Student : public Person
{
public:
int _id; // 学号
};
int main()
{
Person p;
Student s;
// 父类=子类赋值兼容 ->> 切割 切片
// 这里不存在类型转换，是语法天然支持行为
p = s;
Person* ptr = &s;
Person& ref = s; //没有加const，说明没有临时变量产生
//存在类型转换，中间会产生临时变量，
int i = 1;
double d = 2.2;
i = d;
const int& ri = d; //要加const才能引用常量
}
注意： ！！！！！！！！
不能把公有继承改成私有或者保护继承方式，否则实现不了切片；
因为存在访问权限的转换，比如基类中是公有访问限定符，用了保护继承方式，这样继承下来的访问权限就发生了改变，就不可以再赋值给基类了。
基类对象不能赋值给派生类对象。
但是：
1、基类的指针可以通过强制类型转换赋值给派生类的指针。
2、基类的对象可以通过强制类型转换赋值给派生类的引用。
class Person
{
protected:
string _name; // 姓名
string _sex; // 性别
int _age; // 年龄
};
class Student : public Person
{
public:
int _id; // 学号
};
int main()
{
Person p;
Student s;
// 子类 = 父类
// 很危险的，存在越界访问的风险
Student* pptr = (Student*)&p;
Student& ss = (Student&)p;
}
我们都知道在继承体系中基类和派生类都有独立的作用域，那什么是作用域呢？
我们来看看这个例子，如果全局变量和局部变量的名字一样了，那要怎么调用呢？
我们有以下方法：变量名字前面加作用域
举例如下：
#include <iostream>
using namespace std;
int tmp = 0;
int main()
{
int tmp = 233;
cout << tmp << endl; //调用的是局部tmp
cout << ::tmp << endl; //加作用域，调用的是全局变量tmp
return 0;
}
我们再来看看我们的重定义概念：
定义： 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。（在子类成员函数中，可以使用 基类::基类成员 显示访问）
注意： 如果是成员函数的隐藏，只需要函数名相同就构成隐藏。
经典例题1：
class A
{
public:
void fun()
{
cout << "func()" << endl;
}
};
class B : public A
{
public:
void fun(int i)
{
cout << "func(int i)->" << i << endl;
}
};
//以下说法正确的是：
// 1：A和B的func构成函数重载
// 2：编译报错
// 3：运行报错
// 4：A和B的func构成函数隐藏
很明显，根据：如果是成员函数的隐藏，只需要函数名相同就构成隐藏，所以A和B的func函数构成隐藏。
经典例题2：
class A
{
public:
void fun()
{
cout << "func()" << endl;
}
};
class B : public A
{
public:
void fun(int i)
{
cout << "func(int i)->" << i << endl;
}
};
int main()
{
B b;
b.fun(1);
b.fun();
}
//以下说法正确的是：
// 1：A和B的func构成函数重载
// 2：编译报错
// 3：运行报错
// 4：A和B的func构成函数隐藏
因为A和B的func构成函数隐藏，所以基类中的fun()函数被隐藏了，调用不了，从而编译报错。如果想要调用，要在前面加作用域，如：b.A::fun()。
学到现在，我们发现有6个默认成员函数，其中构造函数、析构函数、拷贝构造函数、赋值重载这四个默认成员函数是比较重要的，是我们下面重要研究的方面。
所谓的“默认”就是我们不写，编译器会给我们自动生成一个。所以如果我们不写默认成员函数，编译器会默认生成的会干些什么事情呢？
1、如果我们不写默认生成的派生的构造和析构？
父类继承下来的 (调用父类默认构造和析构处理)
派生类的内置类型和自定义类型成员 (跟普通类一样)
2、 我们不写默认生成的拷贝构造和operator=？
父类继承下来得 (调用父类拷贝构造和operator=)
派生类的内置类型和自定义类型成员 (跟普通类一样)
那什么情况下必须自己写默认函数呢？我们总结出以下三点：
1、父类没有默认构造，需要我们自己显示写构造
2、如果子类有资源需要释放，就需要自己显示写析构
3、如果子类存在浅拷贝问题，就需要自己实现拷贝构造和赋值解决浅拷贝问题
自己写是自己写，那要我们怎么写呢？我们有以下两点：
1、对于父类成员调用父类的对应构造、拷贝构造、operator=和析构处理
2、自己成员按普通类处理。
举例如下：
//构建一个基类
class Person
{
public:
//全缺省，没有参数，编译器自动生成的构造函数才是默认构造函数
Person(const char* name) //基类没有默认构造函数；
: _name(name)
{
cout << "调用Person类构造函数" << endl;
}
Person(const Person& p)
: _name(p._name)
{
cout << "调用Person类拷贝构造函数" << endl;
}
Person& operator=(const Person& p)
{
cout << "调用Person类赋值重载" << endl;
if (this != &p)
_name = p._name;
return *this;
}
~Person()
{
cout << "调用Person类析构函数" << endl;
}
protected:
string _name; // 姓名
};
//构建子类，继承基类Person，下面演示怎么写默认成员函数
class Student : public Person
{
public:
Student(const char* name,int id)
:Person(name) //调用父类的构造函数初始化_name
,_id(id)
{
cout << "调用Student类的构造函数" << endl;
}
Student(const Student& tmp)
:Person(tmp) //这里把子类给父类，会发生切片；调用父类的拷贝构造
,_id(tmp._id)
{
cout << "调用Student类的拷贝构造函数" << endl;
}
Student& operator=(const Student& tmp)
{
if (this != &tmp)
{
Person::operator=(tmp); //调用父类的赋值重载
_id = tmp._id;
}
cout << "调用Student类的赋值重载" << endl;
return *this;
}
~Student()
{
cout << "调用Student类的析构函数" << endl;
}
//子类析构函数结束时，会自动调用父类的析构函数
protected:
int _id; //学号
};
int main()
{
Person p("小明");
Student s("张三",10086);
Student s1(s);
s1 = s;
return 0;
}
注意：
子类析构函数结束时，会自动调用父类的析构函数，这样才能保证先析构子类成员，再析构父类成员；所以我们自己实现子类析构函数时，不需要显示调用父类析构函数。
如果我们想在子类析构函数中强制调用父类的析构函数，要注意什么呢？
~Student()
{
//~Person()
//不能这样直接调用，析构函数名字会被统一处理成destructor()。为了符合多态条件
//这样子类的析构函数跟父类的析构函数就构成隐藏，调用的是子类而不是父类
//要加作用域调用才行
Person::~Person();
}
总结： 从基类继承下来调用父类处理，自己的按普通类基本规则处理。
友元关系不能继承，也就是说基类友元不能访问子类私有和保护成员；
比如他是爸爸的朋友，但是不是我的朋友。
基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子类，都只有一个static成员实例。
举例如下：
class Person
{
public:
static int _count;
Person()
{
_count++;
}
};
int Person::_count = 0; //对静态成员进行初始化
class Student :public Person
{
};
class Teacher :public Person
{
};
int main()
{
Person p;
Student s;
Teacher t;
//调用静态成员可以有两种方式，
//一种是对象. 调用；一种是类名:: 调用
cout << Person::_count << endl;
cout << Student::_count << endl;
cout << Teacher::_count << endl;
cout << p._count << endl;
cout << s._count << endl;
cout << t._count << endl;
cout << &p._count << endl;
cout << &s._count << endl;
cout << &t._count << endl;
return 0;
}
运行结果如下：
我们先来看看什么是单继承和多继承。
单继承：一个子类只有一个直接父类时称这个继承关系为单继承
多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承
有了多继承之后，就有了菱形继承；
菱形继承：菱形继承是多继承的一种特殊情况。
菱形继承的问题：从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题。
举例如下：
//菱形继承
class A
{
public:
int _aa;
};
class B :public A
{
public:
int _bb;
};
class C : public A
{
public:
int _cc;
};
class D :public B,public C
{
public:
int _dd;
};
int main()
{
D d1;
// 这样会有二义性无法明确知道访问的是哪一个
//d1._aa = 0;
// 需要显示指定访问哪个父类的成员可以解决二义性问题，
//但是数据冗余问题无法解决
d1.B::_aa = 0;
d1.C::_aa = 2;
return 0;
}
菱形继承的内存图：
所以为了解决菱形继承的二义性和数据冗余，菱形虚拟继承就出来了；
虚拟继承可以解决菱形继承的二义性和数据冗余的问题。
如上面的继承关系，在B和C的继承A时使用虚拟继承，即可解决问题。需要注意是，虚拟继承不要在其他地方去使用。
举例如下：
//菱形虚拟继承
class A
{
public:
int _aa;
};
class B :virtual public A
{
public:
int _bb;
};
class C : virtual public A
{
public:
int _cc;
};
class D :public B,public C
{
public:
int _dd;
};
int main()
{
D d1;
d1.B::_aa = 1;
d1._bb = 2;
d1.C::_aa = 3;
d1._cc = 4;
d1._dd = 5;
return 0;
}
可是虚拟继承是怎么解决数据冗余和二义性的问题的呢？我们还是先来看看菱形虚拟继承的内存图：
可是为什么D中B和C部分要去找属于自己的A呢？当然是有理由的，看看下面这一种情况就知道了：
D d;
B b = d;
C c = d;
//当子类对象赋值给父类对象时，要发生切片，
//所以d要去找出B/C成员中的A才能赋值过去
B* pb=&d;
pb->_aa=5;
pb->_bb=6;
//同样的道理，子类的地址给父类的指针时，
//父类的指针要找到子类成员的地址才行
public继承是一种是什么的关系。也就是说每个派生类对象都是一个基类对象。
（如Person 和 Student）
组合是一种有什么的关系。假设B组合了A，每个B对象中都有一个A对象。
（如轮胎和汽车 、眼睛和头）
代码举例如下：
class A
{
public :
int _aa;
};
//继承
class B :public A
{
public:
int _bb;
};
class C
{
public:
int _cc;
};
//组合
class D
{
public:
C _target;
int _dd;
};
继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用；术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对子类可见 。
继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。
对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用；
因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。 组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装。
那我们是使用继承好还是组合好呢？
答案是完成符合哪一个就用哪一种方式，都符合就优先组合。
举一个例子：
比如A类合C类都有3个共有成员合3个保护成员；
但是B类公有继承A类，B就可以直接访问A类的公有成员合保护成员；
而D类和C类是组合，D只能访问C类的公有成员。
所以组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装。