C++进阶之继承
目录
一，继承的概念及定义
继承的概念
二，继承的定义
三，基类和派生类对象赋值转换
为什么只能公有继承才能切割，私有和保护继承都不行？
四，继承中的作用域
小测试
五，派生类的默认成员函数
六，继承与友元
七，继承与静态成员
八，复杂的菱形继承及菱形虚拟继承
虚拟继承解决数据冗余和二义性的原理
九，继承的总结和反思
一，继承的概念及定义
继承的概念
继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。
继承的本质是一个复用，之前复用最多的地方是函数中复用，继承则体现在类。
假设我设计老师与学生这两个类，发现他俩具共同有的，有都有自己独立拥有的，如果我们像下图一样再写一遍，就会造成代码冗余
为了解决这个问题就需要用到继承，我们可以用一个Person类存放他俩公有的，用Person链接teacher和student，这样就保证了student和teacher可以用Person中的信息
这个Person就叫做父类或者基类，student和teacher就叫做子类或者派生类。体现在语法上就是
继承不仅会继承父类的成员变量还会继承父类的成员函数
class Person { public: void Print() { cout << "name:" << _name << endl; cout << "age:" << _age << endl; } protected: string _name = "peter"; // 姓名 int _age = 18; // 年龄 }; class Student : public Person { protected: int _stuid; // 学号 }; class Teacher : public Person { protected: int _jobid; // 工号 }; int main() { Student s; Teacher t; s.Print(); t.Print(); return 0; }继承成员变量
继承成员函数
二，继承的定义
定义格式：
继承关系和访问限定符：
继承之后，基类成员访问方式的变化
- 基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。
对于父类中的_aa,虽然子类继承了，但是在子类类里面或者是类外面都不能去用这个_aa
私有成员的意义就是父类有一个成员不想给子类用，就定义成私有，想给子类使用就定义成公有或者保护。对于编译器来说继承下来不可用反而是简单的，不继承下来反而是复杂的，所以编译器就都继承下来，是否可用则通过语法限制
- 基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。
- 实际上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected > private。
- 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。
eg:这里没写继承方式就默认是私有继承，对于Student来说，继承下来的成员变量和成员函数在Student这个类中就都是私有的，类外面就不允许访问。例如Person类中的Print成员函数，就不能去访问它了。
但是这并不会影响到派生类去访问基类中的public成员和protected成员，也不会影响类外面去访问派生类的public成员。
struct默认继承就是public
- 在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡使用protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。
三，基类和派生类对象赋值转换
- 派生类对象 可以赋值给 基类的对象 / 基类的指针 / 基类的引用。这里有个形象的说法叫切片或者切割。寓意把派生类中父类那部分切来赋值过去。
这里不存在类型转换是语法天然支持的行为，如果是类型转换引用是引用不了的，因为中间产生的临时变量具有常性，需要加const，否则编译不过。
为什么只能公有继承才能切割，私有和保护继承都不行？
因为如果是私有继承，那么基类的成员函数和成员变量在派生类中就都变成私有的了，但是基类中的成员函数和变量权限并不改变，此时如果进行切割，可能会存在一个权限的转换。
eg:在派生类中的权限是私有的，切割给基类后权限改变了，变成保护了，这显然是不允许的
- 基类对象不能赋值给派生类对象
普通赋值和强转都是不行的
- 基类的指针可以通过强制类型转换赋值给派生类的指针。
但是这个时候存在越界的风险，因为Student的指针看到空间会变大，但是下面那段空间却不是自己的。
这里访问就崩溃了。
四，继承中的作用域
- 在继承体系中基类和派生类都有独立的作用域。
- 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。（在子类成员函数中，可以使用 基类::基类成员 显示访问）
ps: 局部变量和临时变量编译器会按照就近原则进行访问，也叫局部优先
eg: 如果想访问全局的就用域访问限定符(左边是空的就代表是全局的)
适用到类上面也是一样
class Person { protected: string _name = "小李子"; // 姓名 int _num = 111; // 身份证号 }; class Student : public Person { public: void Print() { cout << " 姓名:" << _name << endl; cout << " 学号:" << _num << endl; } protected: int _num = 999; // 学号 }; int main() { Student s; s.Print(); }Student类中Print函数中访问的_num同样遵循的是就近原则。它访问的就是Student这个类中的_num,而不是继承下来的_num。
如果想要去访问到父类的就需要用到域限定作用符
子类和父类出现同名成员就叫做隐藏或者重定义，可以看出这样代码虽然能跑，但是非常容易混淆
小测试
class A { public: void fun() { cout << "func()" << endl; } }; class B : public A { public: void fun(int i) { A::fun(); cout << "func(int i)->" << i << endl; } }; void Test() { B b; b.fun(10); };A:A和B中的fun()构成函数重载
B:编译报错
C:运行报错
D:A和B中符fun()构成函数隐藏答案：D
解析：函数重载的要求是在同一作用域；成员函数只要函数名相同就构成函数隐藏，与函数中的参数相同或者不相同无关 。
题2：对于这个题目又该选什么呢？
class A { public: void fun() { cout << "func()" << endl; } }; class B : public A { public: void fun(int i) { A::fun(); cout << "func(int i)->" << i << endl; } }; void Test() { B b; b.fun(); };答案：B
解析：改题与上题非常的相似，仅仅是b调用的函数不同，但是两个fun()构成了隐藏，所以此时再去调用父类的fun()就会报错，因为它被隐藏了。如果现在想去调用父类中的fun()可以通过指定类域访问。
- 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。参数可以相同也可以不相同
- 注意在实际中在继承体系里面最好不要定义同名的成员。
五，派生类的默认成员函数
对于这样一个类
class Person
{
public:
Person(const char* name = "peter")
: _name(name)
{
cout << "Person()" << endl;
}
Person(const Person& p)
: _name(p._name)
{
cout << "Person(const Person& p)" << endl;
}
Person& operator=(const Person& p)
{
cout << "Person operator=(const Person& p)" << endl;
if (this != &p)
_name = p._name;
return *this;
}
~Person()
{
cout << "~Person()" << endl;
}
protected:
string _name; // 姓名
};
class Student :public Person
{
public:
protected:
int _num; //学号
string _a;
};
派生类的默认四个默认成员函数，我们不写，编译器默认生成的会干什么事情呢？
我们不写默认生成的派生类的构造和析构函数
a.父类继承下来的成员--调用父类构造和析构处理
b.派生类自己的成员变量（内置类型和自定义类型成员）--内置类型不初始化，自定义类型调用它自己的构造，析构函数。
我们不写默认生成的派生类的拷贝构造和operator=
a.父类继承下来的成员--调用父类的拷贝构造和operator=
b.派生类自己的成员变量（内置类型和自定义类型成员）--内置类型完成浅拷贝，自定义类型调用它自己的拷贝构造和operator=。
总结：继承下来成员变量的调用父类处理，派生类自己的成员变量按普通类的基本规则处理。
如果我们要自己写派生类的四个成员函数呢？如何自己写？什么情况下需要自己写？
需要自己写的情况：
1.0 父类没有默认构造函数，需要我们去写。
派生类的默认构造函数对于自己的成员可以处理，对于父类的就去调用它的构造函数，但此时父类没有默认构造函数，这个时候就需要我们自己写。
2.0 如果派生类有资源需要释放，就需要自己显示写析构函数。
3.0如果派生类存在浅拷贝问题，就需要自己实现拷贝构造和赋值解决浅拷贝问题。
如何去写：
整体思路：父类成员调用父类对应的构造，拷贝构造，operator=和析构处理，派生类成员按照普通类处理。
1.0构造函数
这样写是不行的
正确写法：
2.0拷贝构造
赋值运算符
ps:对于父类要进行域的限制，如果没进行限制，就会隐藏父类的operator=，造成无限递归
ps:用赋值初始化调用的是拷贝构造，因为这时候是在定义s2,赋值针对的是两个已经实例化出的对象。
3.0析构函数
如果我们显示的写出来，报错了，调用不到父类的析构
原因还是隐藏问题，实际上析构函数的名字会被统一处理成destruction(),那么子类与父类的析构函数就构成了隐藏。
如果加个限定就可以调用了
其次我们还发现如果这样写父类的析构函数调用了两次
如果父类没有动态开辟空间还好，如果父类动态开辟了空间调用两次析构函数，就会发生同一块空间被释放了两次的问题。
正确写法：
其他的函数都需要我们显示的去调用，但是析构函数却不用显示的去调用，子类析构函数结束会自动调用父类的析构函数。原因就是这里子类和父类的构造和析构遵从一个规则，构造的时候，父类先初始化，子类再初始化；析构的时候，子类先析构，父类再析构，所以我们自己实现子类析构函时，不需要显示调用父类析构函数，这样才能保证先析构子类成员，再析构父类成员 。
完整代码：
class Person
{
public:
Person(const char* name )
: _name(name)
{
cout << "Person()" << endl;
}
Person(const Person& p)
: _name(p._name)
{
cout << "Person(const Person& p)" << endl;
}
Person& operator=(const Person& p)
{
cout << "Person operator=(const Person& p)" << endl;
if (this != &p)
_name = p._name;
return *this;
}
~Person()
{
cout << "~Person()" << endl;
}
protected:
string _name; // 姓名
};
class Student :public Person
{
public:
Student(const char* name = "李四", int num = 1)
:_num(num)
,Person(name)
{}
Student(const Student& s)
:Person(s) //这里运用的就是切片
, _num(s._num)
{}
Student& operator=(const Student& s)
{
if (this != &s)
{
Person::operator=(s); //切片
_num = s._num;
}
return *this;
}
~Student()
{
}
protected:
int _num=1; //学号
};总结：子类自己的成员就按照普通类的方式处理，继承的父类的成员就要调用父类几个默认成员函数处理。
小问题：下面这段代码的输出结果是什么？
#include
using namespace std;
class Base
{
public:
Base(int x = 0)
{
cout << x;
}
};
class Derived : public Base
{
public:
Derived(int x = 0)
{
cout << x;
}
private:
Base val;
};
int main()
{
Derived d(1);
return 0;
} 答案是001.
原因：子类构造对象首先会调用父类的构造函数，打印出0，然后在进行初始化自定义成员变量val,初始化val就会调用val的默认构造函数，再次打印0，最后在调用子类的构造函数，传的参数是1，最后打印1，所以结果是001.
借助打印帮助理解。
六，继承与友元
友元关系不能继承，也就是说父类友元不能访问子类私有和保护成员
eg：对于这段代码，父类的友元函数就不能去访问子类成员
class Student; //像函数声明一样，Student在下面，而我们当前就使用需要声明一下
class Person
{
public:
friend void Display(const Person& p, const Student& s);
protected:
string _name; // 姓名
};
class Student : public Person
{
protected:
int _stuNum; // 学号
};
void Display(const Person& p, const Student& s)
{
cout << p._name << endl;
cout << s._stuNum << endl;
}
int main()
{
Person p;
Student s;
Display(p, s);
}
如果想要去访问子类的需要在子类中也声明下Display也是子类的友元。
class Student;
class Person
{
public:
friend void Display(const Person& p, const Student& s);
protected:
string _name; // 姓名
};
class Student : public Person
{
friend void Display(const Person& p, const Student& s);
protected:
int _stuNum; // 学号
};
void Display(const Person& p, const Student& s)
{
cout << p._name << endl;
cout << s._stuNum << endl;
}
int main()
{
Person p;
Student s;
Display(p, s);
}
七，继承与静态成员
eg:
class Person
{
public:
Person()
{
++_count;
}
protected:
string _name; // 姓名
public:
static int _count; // 统计人的个数。
};
int Person::_count = 0;
class Student : public Person
{
protected:
int _stuNum; // 学号
};
class Graduate : public Student
{
protected:
string _seminarCourse; // 研究科目
};
void TestPerson()
{
Student s1;
Student s2;
Graduate s3;
cout << " 人数 :" << Person::_count << endl;
cout << " 人数 :" << Student::_count << endl;
cout << " 人数 :" << Graduate::_count << endl;
cout << &Person::_count << endl;
cout << &Student::_count << endl;
cout << &Graduate::_count << endl;
Person::_count = 0;
cout << " 人数 :" << Person::_count << endl;
}
int main()
{
TestPerson();
}
八，复杂的菱形继承及菱形虚拟继承
单继承：一个子类只有一个直接父类时称这个继承关系为单继承
多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承
菱形继承：菱形继承是多继承的一种特殊情况。
菱形继承的问题：从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题。在Assistant的对象中Person成员会有两份。
eg:
class Person
{
public:
string _name; // 姓名
};
class Student : public Person
{
public:
int _num; //学号
};
class Teacher : public Person
{
public:
int _id; // 职工编号
};
class Assistant : public Student, public Teacher
{
public:
string _majorCourse; // 主修课程
};
访问_id,_num都没有问题，但是访问_name就出现了问题，因为_name有两份，这样会有二义性无法明确知道访问的是哪一个。
我们可以通过指定作用域解决
需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决。
假设Person类中有一个存储40000字节的数组。
Assistant继承下来以后就有了80000个字节，我的本意就是存40000个字节，但是现在有多了40000个，这样空间就浪费了。
所以为了解决上述问题，C++又推出了一个新的语法虚继承，虚拟继承可以解决菱形继承的二义性和数据冗余的问题。如上面的继承关系，在Student和Teacher的继承Person时使用虚拟继承，即可解决问题。需要注意的是，虚拟继承不要在其他地方去使用。
class Student : virtual public Person
{
public:
int _num; //学号
};
class Teacher : virtual public Person
{
public:
int _id; // 职工编号
};访问的_name都是同一个都是Person类中的_name; 并且也没有数据冗余。
虚拟继承解决数据冗余和二义性的原理
class A
{
public:
int _a;
};
//class B : public A
class B : virtual public A
{
public:
int _b;
};
//class C : public A
class C : virtual public A
{
public:
int _c;
};
class D : public B, public C
{
public:
int _d;
};
int main()
{
D d;
d.B::_a = 1;
d.C::_a = 2;
d._b = 3;
d._c = 4;
d._d = 5;
d._a = 0;
return 0;
}
不使用虚继承的内存窗口：通过这个内存窗口发现，先继承的B是排在后继承的C的前面，最后继承的D在最后
eg:如果先继承C,再继承B，C就排在B的前面
使用虚继承的内存窗口：
针对B与C里面的_a,使用的空间变成同一块
之前B里面有份_a,C里面也有份_a,这样就会有数据冗余和二义性，从实际的角度来说把_a放B里面和放C里面都不好,所以就把他放在一个公共的地方(就好比一家人只有一辆汽车，放在老大家不好，放在老二家也不好，所以把这辆车放在父母家，谁要用，谁就去拿)
其他成员
我们发现多了两个东西
由于我们的机器是小端字节序，从右向左读，一个是01017bdc,一个是01017be4.我们在通过一个内存窗口去看。
00000014是16进制换算成10进制就是20，0000000c换成10进制就是12，实际上这个地方存的是偏移量或者叫做相对距离(B和C与公共A的偏移量)
这里可以分析出D对象中将A放到的了对象组成的最下面，这个A同时属于B和C，那么B和C如何去找到公共的A呢？这里是通过了B和C的两个指针，指向的一张表。这两个指针叫虚基表指针，这两个表叫虚基表。虚基表中存的偏移量。通过偏移量可以找到下面的A。A一般叫做虚基类。
D d;
B b = d;
C c = d;小问题：以下这种情况是菱形继承吗？如果是虚继承应该在哪里进行继承？
答：这种继承也是菱形继承，虚继承应该在B和C的位置继承，解决的是A的数据冗余和二义性
我们日常在使用中尽量不要定义出菱形继承
九，继承的总结和反思
(2)组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象。
eg:车与轮胎的关系，眼睛与耳朵的关系
组合这么好，可以抛弃继承吗？答案是不可以的，多态就是建立在继承的基础上的。