C++--继承(继承的概念与定义、派生类默认成员函数、菱形继承及菱形虚拟继承)
一、继承的概念及定义
1、继承的概念
继承机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加新的功能，这样产生新的类，新类称为派生类或基类。继承是类设计层次的复用，呈现了面向对象程序设计的层次结构。
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;
}
继承后父类的Person的成员（成员函数+成员变量）都会变成子类的一部分。这里体现出了Student和Teacher复用了Person的成员。下面我们使用监视窗口查看Student和Teacher对象，可以看到变量的复用。调用Print可以看到成员函数的复用。
2、继承定义
2.1、定义格式
下面我们看到Person是父类(基类)，Student是子类(派生类)。
2.2、继承方式和访问限定符
2.3、继承基类成员访问方式的变化
| 类成员/继承方式 | public继承 | protected继承 | private继承 |
|---|---|---|---|
| 基类的public成员 | 派生类的public成员 | 派生类的protected成员 | 派生类的private成员 |
| 基类的protected成员 | 派生类的protected成员 | 派生类的protected成员 | 派生类的private成员 |
| 基类的private成员 | 在派生类中不可见 | 在派生类中不可见 | 在派生类中不可见 |
总结：
1、基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员在派生类中还是存在，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。
但是我们还是可以调用Print方法打印_name的值，不可访问是指我们不管在派生类里还是派生类外面都不可访问。
2、基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但是需要在派生类中能被访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。
3、除了基类的私有成员在子类中都是不可见的。基类的其他成员在子类的访问方式=min(成员在基类的访问限定符，继承方式)，权限：public>protected>private。
4、还需要注意：class的默认继承方式是private，struct的默认继承方式是public。
二、基类和派生类对象赋值转换
- 派生类对象可以赋值给基类的对象 / 基类的指针 / 基类的引用。称为切割或切片。寓意把派生类中父类的那部分切来赋值过去。
- 基类对象不能赋值给派生类。
class Person
{
protected :
string _name; // 姓名
string _sex; // 性别
int _age; // 年龄
};
class Student : public Person
{
public :
int _No ; // 学号
};
int main()
{
Student sobj ;
// 1.子类对象可以赋值给父类对象/指针/引用
Person pobj = sobj ;
Person* pp = &sobj;
Person& rp = sobj;
//2.基类对象不能赋值给派生类对象
//sobj = pobj;
// 3.基类的指针可以通过强制类型转换赋值给派生类的指针
pp = &sobj
Student* ps1 = (Student*)pp; // 这种情况转换时可以的。因为pp本身就是指向一个Student*类型
ps1->_No = 10;
pp = &pobj;
Student* ps2 = (Student*)pp; // 这种情况转换时虽然可以，但是会存在越界访问的问题
ps2->_No = 10;
return 0;
}
三、继承中的作用域
- 1、在继承体系中基类和派生类都是独立的作用域
- 2、子类和父类中有同名成员时，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏(重定义)。（在子类成员函数中，可以使用基类::基类成员 显示访问）。
- 3、对于成员函数的隐藏，只要函数名相同就构成隐藏。
成员属性构成重定义：
// Student的_num和Person的_num构成隐藏关系，可以看出这样代码虽然能跑，但是非常容易混淆
class Person
{
protected :
string _name = "小李子"; // 姓名
int _num = 111; // 身份证号
};
class Student : public Person
{
public:
void Print()
{
cout<<" 姓名:"<<_name<< endl;
cout<<" 身份证号:"<<Person::_num<< endl; //通过基类::基类成员 显示访问
cout<<" 学号:"<<_num<<endl;
}
protected:
int _num = 999; // 学号
};
void Test()
{
Student s1;
s1.Print();
};
成员函数构成重定义：
// B中的fun和A中的fun不是构成重载，因为不是在同一作用域
// B中的fun和A中的fun构成隐藏，成员函数满足函数名相同就构成重定义。
class A
{
public:
void fun()
{
cout << "func()" << endl;
}
};
class B : public A
{
public:
void fun(int i)
{
cout<<"void fun(int i)"<<endl;
}
};
void test(){
B b;
b.func(10);
}
四、派生类的默认成员函数
"默认"的意思就是指我们不写，编译器会为我们自动生成，那么在派生类中，编译器主要为我们生成以下几个默认成员函数：
4.1、构造函数
派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。不能自己显示去初始化。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。
派生类对象初始化先调用基类构造再调用派生类构造。
class Person{
public:
Person(const char* name="peter")
:_name(name)
{
cout<<"Person()"<<endl;
}
protected:
string _name;
}
class Student:public Person{
public:
Student(const char* name,int num)
:Person(name),_num(num)
{
cout<<"Student()"<<endl;
}
protected:
int _num;//学号
}
4.2、拷贝构造函数
派生类的拷贝构造函数必须调用基类的拷贝构造函数完成基类的拷贝构造。
class Person{
public:
Person(const Person& p )
:_name(p._name)
{
cout<<"Person(const Person& p)"<<endl;
}
protected:
string _name;
}
class Student:public Person{
public:
Student(const Student& s)
:Person(s),_num(s._num)
{
cout<<" Student(const Student& s)"<<endl;
}
protected:
int _num;//学号
}
4.3、赋值运算符重载函数
派生类的operator=必须要调用基类的operator=完成基类的复制。
class Person{
public:
Person& operator=(const Person& p)
{
cout<<"Person operator=(const Person& p)"<< endl;
if(this!=&p)
_name=p._name;
return *this;
}
protected:
string _name;
}
class Student:public Person{
public:
Student& operator=(const Student& s)
{
cout<<"Student& operator= (const Student& s)"<< endl;
if(this!=&s)
{
Person::operator=(s); //要显示指定调用父类的operator=，因为子类和父类构成重定义
_num=s._num;
}
return *this;
}
protected:
int _num;//学号
}
4.4、析构函数
派生类的析构函数会在被调用完成后
自动调用基类的析构函数清理基类的成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。
派生类对象析构清理先调用派生类析构再调用基类的析构。
class Person{
public:
~Person()
{
cout<<"~Person()"<<endl;
}
protected:
string _name;
}
class Student:public Person{
public:
//两个迷惑点：
//1、子类的析构函数和父类的析构函数构成隐藏，所有类的析构函数，名字会被统一处理成destructor
//2、自己显示调用，会存在父类先析构，不符合先构造先析构，后构造后析构的原则。
~Student()
{
//Person::~Person(); 不要显示调用，要保证子类先析构
cout<<" ~Student()"<<endl;
}
protected:
int _num;//学号
}
编译器在出作用域时自动调用父类的析构函数，看以下汇编语言：
~Student()
{
008E3D50 push ebp
008E3D51 mov ebp,esp
008E3D53 push 0FFFFFFFFh
008E3D55 push 8EAB30h
008E3D5A mov eax,dword ptr fs:[00000000h]
008E3D60 push eax
008E3D61 sub esp,0CCh
008E3D67 push ebx
008E3D68 push esi
008E3D69 push edi
008E3D6A push ecx
008E3D6B lea edi,[ebp-0D8h]
008E3D71 mov ecx,33h
008E3D76 mov eax,0CCCCCCCCh
008E3D7B rep stos dword ptr es:[edi]
008E3D7D pop ecx
008E3D7E mov eax,dword ptr [__security_cookie (08EF008h)]
008E3D83 xor eax,ebp
008E3D85 push eax
008E3D86 lea eax,[ebp-0Ch]
008E3D89 mov dword ptr fs:[00000000h],eax
008E3D8F mov dword ptr [this],ecx
008E3D92 mov ecx,offset _6235FB68_testvecotr@cpp (08F202Ah)
008E3D97 call @__CheckForDebuggerJustMyCode@4 (08E1537h)
cout << "~Student()" << endl;
008E3D9C mov esi,esp
008E3D9E push offset std::endl<char,std::char_traits<char> > (08E1055h)
008E3DA3 push offset string "~Student()" (08ECDF0h)
008E3DA8 mov eax,dword ptr [__imp_std::cout (08F00E0h)]
008E3DAD push eax
008E3DAE call std::operator<<<std::char_traits<char> > (08E12B2h)
008E3DB3 add esp,8
008E3DB6 mov ecx,eax
008E3DB8 call dword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (08F00A0h)]
008E3DBE cmp esi,esp
008E3DC0 call __RTC_CheckEsp (08E13D9h)
}
008E3DC5 mov ecx,dword ptr [this]
008E3DC8 call Person::~Person (08E1177h) //当出了作用域时，编译器自动调用父类的析构函数
五、继承与友元
友元关系不能继承，也就是说基类友元不能访问子类私有和保护成员
六、继承与静态成员
基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生多少个子类，都只有一个static成员实例。
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 ;
Student s3 ;
Graduate s4 ;
cout <<" 人数 :"<< Person ::_count << endl;
Student ::_count = 0;
cout <<" 人数 :"<< Person ::_count << endl;
}
//运行结果：
人数 :4
人数 :0
七、复杂的菱形继承及菱形虚拟继承
单继承：一个子类
只有一个直接父类时称这个继承关系为单继承。
多继承：一个子类有
两个或以上直接父类时称这个继承关系为多继承
菱形继承：菱形继承是多继承的一种特殊情况。
菱形继承的问题：从下面的对象成员模型构造，可以看出菱形继承有
数据冗余和二义性的问题。在Assistant的对象中Person会有两份。
class Person
{
public:
string _name; // 姓名
};
class Student : public Person
{
protected:
int _num; //学号
};
class Teacher : public Person
{
protected:
int _id; // 职工编号
};
class Assistant : public Student, public Teacher
{
protected:
string _majorCourse; // 主修课程
};
void Test()
{
// 这样会有二义性无法明确知道访问的是哪一个
Assistant a;
a._name = "peter";
// 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
a.Student::_name = "xxx";
a.Teacher::_name = "yyy";
}
虚拟继承可以解决菱形继承的二义性和数据冗余的问题。如上面的继承关系，在Student和Teacher的继承Person的时候使用虚拟继承，即可解决问题，需要注意，虚拟继承不要在其他地方使用。
class Person
{
public:
string _name; // 姓名
};
class Student :virtual public Person //加关键字virtual
{
protected:
int _num; //学号
};
class Teacher :virtual public Person
{
protected:
int _id; // 职工编号
};
class Assistant : public Student, public Teacher
{
protected:
string _majorCourse; // 主修课程
};
void Test()
{
// 这样会有二义性无法明确知道访问的是哪一个
Assistant a;
a._name = "peter";
// 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
a.Student::_name = "xxx";
a.Teacher::_name = "yyy";
}
虚拟继承解决数据冗余和二义性的原理
为了研究虚拟继承的原理，我们给出了一个简化的菱形继承继承体系，再借助内存窗口观察对象成员的模型。
菱形继承：
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::_a = 1;
d.C::_a = 2;
d._b = 3;
d._c = 4;
d._d = 5;
return 0;
}
菱形继承可以看到数据的冗余性，_a属性在两块空间都有存储。
菱形虚拟继承：
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;
};
int main() {
D d;
d.B::_a = 1;
d.C::_a = 2;
d._b = 3;
d._c = 4;
d._d = 5;
return 0;
}
下图是菱形虚拟继承的内存对象成员模型：这里可以分析出D对象中A放到了对象组成的最下面，这个A同时也是属于B、C，那么B、C是如何找到公共的A呢？这里是通过了B和C的两个指针，指向的一张表。这两个指针叫虚基表指针，这两个表叫虚基表。虚基表中存的偏移量。通过偏移量可以找到A。
当发生派生类对象转换为基类对象时，那么基类对象怎么去找属于自己的那一部分数据呢？
D d;
B b=d;
C c=d;
下图是上面菱形继承的原理解释图：
