C++ 继承

一 理解继承

继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。

using namespace std;
class person {
public:
	person() {
		cin >>_name >> _age >> _sex;
	}
protected:
	string _name;
	int _age;
	string _sex;
};
class teacher :public person {
public:
	teacher() {
		cin >> _id;
	}
	void print() {
		cout << _name << ' ' << _age << ' ' << _sex << ' ' << _id << endl;
	}
protected:
	int _id;
};
int main() {
	teacher p1;
	p1.print();
	return 0;
}

teacher 是一个 person 满足继承关系 ，继承了person类的所有成员，提高了代码的复用性。

继承关系中 person叫作父类或者基类，teacher 叫作person的派生类

二 继承方式

继承方式有三种： public 继承，protect 继承 ，protected 保护，private 私有

他们于类成员的访问限定符虽然关键字一样，意义却不一样

       

有三个要点

1.基类的private成员无论以什么继承方式来继承，都在派生类中不可见。

"不可见的含义"

        i.虽然被继承 ，但是无论类外还是类里都不可访问

        ii.被继承下来的“可见”函数，仍然可以访问 

using namespace std;
class person {
public:
	person():_name("张三"),_sex("男"),_age(19) { ; }
	void print() {
		cout << _name << ' ' << _sex << ' ' << _age << ' '  << endl;
	}
private:
	string _name;
	int _age;
	string _sex;
};
class teacher :public person {
	;
};
int main() {
	teacher p1;
	p1.print();//可以访问被继承下来的私有成员
	return 0;
}

2.除了基类的private成员外 继承结果取继承方式 与 基类中访问限定符的较小权限

3. protect 成员 与 private 成员 一样 只能在类里访问，在类外不可以访问，可以推测出，protect这个关键字就是为了继承而设计的。

三 特殊成员

1.友元 

友元不可被继承

2.静态成员

由于静态成员储存在静态区：

静态成员可以被继承 继承规则遵循普通变量 ，但一个变量名只能对应一个，即所有派生类继承下来的静态成员和基类的那个静态成员是 同一个地址下的同一个变量 。

四 继承中的作用域

1.子类可以直接访问继承下来的父类成员（除私有不可见）

2.子类成员与继承下来的父类成员有独立的作用域，若成员名相同 不会报错，而是屏蔽父类成员的直接访问，这种情况叫作“隐藏”或“重定义”，访问需指定作用域为父类名，注意基类和派生类的成员函数只要同名就会触发隐藏，不能构成重载！

#include<iostream>
#include<string>
using namespace std;
class person {
public:
protected:
	int _age;
};
class teacher : public person {
public:
	teacher() :_age(19) {
		person::_age=_age;
	}
	int _age;
};

五 切片规则

继承中的特殊语法 ，即 子类对象/子类地址可以直接赋值给父类类型的对象和引用，/指针

也叫做切片（切割）

1.被赋值后的父类指针 指向 子类中继承下来的父类部分

2.被赋值后的父类引用 为 子类中继承下来的父类部分 的引用

3.赋值的父类对象会调用赋值重载（传参时二次切片）后与 被子类中的父类部分赋值

teacher t1;
//切片
person p1 = t1;
person& rp = t1;
person* pp = &t1;
p1.print();
rp.print();
pp->print();

四 默认成员函数

派生类除了析构，都满足“先父后子”的规则，析构相反。

1.在实例化时必须先自动调用 父类的"默认构造函数" 构造继承下来的父类成员，再执行子类的构造函数，若父类没有默认构造函数，则需在子类初始化列表中 显示调用。

2.在析构 结束后 自动调用 父类的析构函数。

using namespace std;
class person {
public:
	person(const char* name,const char* sex,int age):_name(name),_sex(sex),_age(age) { ; }
	void print() {
		cout << _name << ' ' << _sex << ' ' << _age << ' '  << endl;
	}
private:
	string _name;
	int _age;
	string _sex;
};
class teacher :public person {
public:
	teacher():person("张三","男",19) {//满足初始化子类前，必须先初始化好父类成员的原则，故不能在函数体内调用父类构造函数。
		;
	}
	~teacher() {//先自动调用了person的析构
		;
	}
};
int main() {
	teacher p1;
	p1.print();//可以访问被继承下来的私有成员
	return 0;
}

3.在子类赋值重载之前 自动调用 父类的赋值重载（传参时切片）处理继承下来的父类部分

4.在子类的拷贝构造前 自动调用 父类的拷贝构造 （传参时切片）处理继承下来的父类部分

五 菱形继承问题

        这种情况叫作菱形继承

#include<iostream>
#include<string>
using namespace std;
class person {
public:
	person(int age) : _age(age) { ; }
private:
	int _age;
};
class teacher : public person {
public:
	teacher() :person( 19) {;}
};
class student : public person {
public:
	student() :person(17) { ; }
};
class worker : public teacher, public student {
public:
	worker() :_age(20){ ; }
	int _age;
};

int main() {
	worker w1;
	return 0;
}

 普通菱形继承带来的两个问题

1.空间浪费

age年龄作为人的属性存了三份

        

2.二义性

        这时候访问成员必须要带作用域，存在歧义。

虚继承和虚基类

为解决菱形继承带来的问题，C++引入了虚基类，可以在间接继承共同基类时，只保留一份基类成员。

声明方式

在继承方式前加上 virtual 关键字

虚基类不是在声明基类时声明，而是在声明派生类，通过指定虚拟继承方式声明的。

虚基类的初始化与存储位置

虚基类只初始化一次，储存在最后继承的子类中，由最后继承的子类初始化。

虚拟继承方式

子类的成员变为

虚基表指针+子类成员

或

虚基表指针+子类成员+虚基类成员，有没有虚基类成员取决于此类是否是最后的派生类，虚基表里存的虚基类的成员与子类地址的偏移量

3.一个类可以有多个虚基类他们连续存储 它的虚基表指针指向第一个虚基类的偏移量

#include<iostream>
#include<string>
using namespace std;
class person {
public:
	person(int age) : _age(age) { ; }
private:
	int _age;
};
class teacher : virtual public person {
public:
	teacher(int age) :person(age) { ; }
};
class student : virtual public person {
public:
	student(int age) :person(age) { ; }
};
class worker :virtual public teacher,virtual public student {
public:
	worker() :_age(20),teacher(19),student(20),person(30){ ; }
	int _age;
};

 1.worker同时是 person teacher student 三个类共同的最后派生类 所以worker的虚基表指针指向第一个虚基类的偏移量

2.而 teacher 的不是其父类person的最后派生类，所以它里面没有虚基类，只有虚基表指针，指向person的偏移量

student同理

最合理解决方法

只让teacher和 student使用虚继承

class worker :public teacher, public student {
public:
	worker() :_age(20),teacher(19),student(20),person(30){ ; }
	int _age;
};

这样worker只是 person的最后派生类 person 是worker的虚基类，其他不变。

相比全部使用虚拟继承的方式 少了一个瞎折腾的虚基表指针，提高效率 节省空间。