C++——继承

学习C++对于初学者的第一挑战是前面的类和对象(封装)，而第二挑战则是继承与多态：

这可以说是面向对象的语言都要具备的三大特性；也是学习这些语言的“入门槛”；但由于C++出现较早，在这方面比其它语言学习起来要更为复杂(坑多多)，也使得一些初学者在学习过程中放弃了C++，这实在令人感叹......

目录

封装

继承

1概念 

2继承方式与访问限定符

3访问权限

4基类与派生类的赋值

​编辑 5继承中的作用域

6派生类的默认成员函数

6.1构造函数 

6.2拷贝函数

6.3赋值重载/析构函数

​编辑

7继承与友元

8继承与静态成员

9菱形继承与菱形虚拟继承

9.1单继承

9.2多继承 

9.3菱形继承 

9.4菱形虚拟继承 

9.5分析菱形虚拟继承模型

10继承的总结与反思

---

封装

1数据和方法放到一起，把想给访问的定义成共有，不想给你访问的定义成私有和保护

2一个类型放到另一个类型中，通过typedef成员函数调整，封装一个全新的类型：如迭代器：

而对于封装的具体学习在：类和对象中进行体现，这里就不详细叙述了，有兴趣就跳转我写的类和对象：http://t.csdnimg.cn/GpVAt 

继承

如果我们想创建以下几个类：

它们的成员变量都要有：name,age,address；如果按照通常的思路：要创建出四个类，每个类中写上一遍相同的成员变量；这不免会有些冗余：那有什么更好的方法吗？

我们可以用一个类：里面写上它们共同的成员变量（父类），在以继承的方式继承到各个类中（子类），子类中就继承了父类中的成员变量了，就不用自己去写；

这也是继承带来的优点之一

1概念 

 继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，

它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程：

以前我们接触的复用都是函数复用，继承是类设计层次的复用。

而上面我们所说的解决方法用代码可以写成： 

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是子类，也称作派生类：

2继承方式与访问限定符

3访问权限

父类的成员，继承到派生类以后，访问权限怎么规定？

总结：

1.基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的
2基类的其它成员在子类的访问形式：public > protected > private

4基类与派生类的赋值

派生类对象 可以赋值给 基类的对象 / 基类的指针 / 基类的引用。

这里有个形象的说法叫切片或者切割。寓意把派生类中父类那部分切来赋值过去。

class Person
{
protected:
	string _name; // 姓名
	string _sex; // 性别
	int _age; // 年龄
};
class Student : public Person
{
public:
	int _No; // 学号
};
int main()
{
	Student st;
	// 1.子类对象可以赋值给父类对象/指针/引用
	Person p = st;
	Person& ref = st;
	Person* ptf= &st;
	return 0;
}

对应关系如下： 

public继承子类与父类的关系是：子类 is a 父类：每个子类对象都是一个特殊的父类对象！

父类对象能用指针指向子类当中父类继承的那部分，那我应该能对子类对象的继承成员进行修改：

 5继承中的作用域

1. 在继承体系中基类和派生类都有独立的作用域。
2. 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。（但在子类成员函数中，可以使用 基类::基类成员 显示访问）
3. 函数名相同就构成隐藏。

// B中的fun和A中的fun构成隐藏，成员函数满足函数名相同就构成隐藏。
class A
{
public:
	void fun()
	{
		cout << "func()" << endl;
	}
};
class B : public A
{
public:
	void fun(int i)
	{
		//A::fun();显示调用A的fun()
		cout << "func(int i)->" << i << endl;
	}
};
int main()
{
	B b;
	b.fun(10);
	return 0;
};

6派生类的默认成员函数

先来回忆回忆六大成员函数：

 派生类中的成员函数中会有哪些变化呢？

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(int num, const char* str, const char* name)
		:Person(name)//要显示构造
		, _num(num)
		, _str(str)
		
	{
		cout << "Student()" << endl;
	}

	// s2(s1)
	Student(const Student& s)
		:Person(s)
		, _num(s._num)
		, _str(s._str)
	{}

	Student& operator=(const Student& s)
	{
		if (this != &s)
		{
			Person::operator=(s);//显示写
			_num = s._num;
			_str = s._str;
		}

		return *this;
	}

	// 子类的析构也会隐藏父类
	// 因为后续多态的需要，析构函数名字会被统一处理成destructor
	~Student()
	{
		// 显示写无法先子后父
		//Person::~Person();

		cout << _name << endl;
		cout << "~Student()" << endl;

		// 注意，为了析构顺序是先子后父，子类析构函数结束后会自动调用父类析构
	}

protected:
	int _num;	 //学号
	string _str;

	// 父类成员，当成一个整体的一个自定义类型成员
	// 子类的成员(跟以前一样)
	// a、内置类型
	// b、自定义类型
};

//与BB对象进行类比理解
class BB
{
public:
	BB(int num, const char* str, const char* name)
		:_p(name)
		,_num(num)
		,_str(str)
	{}
private:
	Person _p;
	int _num;
	string _str;
};

int main()
{
	//类比构造
	//BB bb(1, "xxxx", "张三");

	//构造
	Student s1(1, "xxxx","张三");

	//拷贝
	Student s2(s1);
	
	//赋值
	Student s3(2, "yyy", "李四");
	s1 = s3;

	//析构
	Person p("李四");
	p.~Person();

	return 0;
}

6.1构造函数 

在子类中的父类成员，当成一个整体的一个自定义类型成员；其它规则与构造函数相同

构造继承过来的父类成员时要调用父类的构造函数来进行初始化：

初始化列表要显示写父类的构造：Person(name)，不写编译器会报错（如果是Person没有构造编译器也会报错）

你也可以理解成：子类继承父类成员是隐藏在子类中，构造父类成员时是希望你去复用父类的构造函数来方便初始化！！

6.2拷贝函数

一般情况下不写拷贝函数，编译器会为我们默认生成一个；涉及深拷贝才要写

派生类中的涉及基类的成员我们构造函数一样：父类的成员看成一个整体，去调用它的拷贝

那去调用父类的拷贝函数时参数要写什么呢？-->直接传入要拷贝的子类对象进行切片

6.3赋值重载/析构函数

赋值重载要显示写要注意：子类当中会隐藏父类的赋值重载，在写子类的赋值重载要注意显示写父类的赋值重载！！ 

同样，子类的析构其中会隐藏父类的析构(要显示调用！！)

原因：后续多态的需要，编译器会把析构函数统一写成destructor 

总结:

7继承与友元

友元关系不能继承，也就是说基类友元不能访问子类私有和保护成员

class 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);
}

总结：父亲的朋友一定不是你的朋友！

8继承与静态成员

基类定义了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; // 研究科目
};

int main()
{
	Student s1;
	Student s2;
	Student s3;
	Graduate s4;

	cout << "人数:" << Person::_count << endl;//几个子类就是几个count
	Student::_count = 0;
	cout << "人数:" << Person::_count << endl;
}

创建子类，父类会被当成整体类型来调用它的默认构造：++count 

9菱形继承与菱形虚拟继承

C++对复用的方式体现在：1函数逻辑的复用；2模板；3继承

那继承有没有可能会出现继承多个父类来达到double继承？？ 有的：多继承~

而我们在上面介绍的继承方式全都是单继承：毕竟比较常用~

9.1单继承

单继承：一个子类只有一个直接父类时称这个继承关系为单继承

9.2多继承 

多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承 

比如：西红柿既可以是水果，有可以是蔬菜

9.3菱形继承 

 而在多继承中，又会出现一种特殊的多继承——菱形继承

比如：在职教师，同时在读博

菱形继承的出现，就会带来：1数据冗余；2数据二义性 

 以代码的方式来进行观察：

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; // 主修课程
};

int main()
{
    Assistant a;
	a._name = "peter";//Teacher和stduent都有变量name

	// 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
	a.Student::_name = "xxx";
	a.Teacher::_name = "yyy";
}

9.4菱形虚拟继承 

 解决菱形继承的方法——菱形虚拟继承：

多继承的继承方式改为：虚拟继承(加virtual关键字)

class Person
{
public:
	string _name; // 姓名
};

class Student : virtual public Person
{
protected:
	int _num; //学号
};

class Teacher : virtual public Person
{
protected:
	int _id; // 职工编号
};

class Assistant : public Student, public Teacher
{
protected:
	string _majorCourse; // 主修课程
};

int main()
{
	Assistant a;
	a._name = "peter";
	cout << a._name << endl;
	return 0;
}

9.5分析菱形虚拟继承模型

class A
{
public:
	int _a;
};

//class B : public A
class B : virtual public A
{
public:
	int _b;
	int _b1;
	int _b2;

};

//class C : public A
class C : virtual public A
{
public:
	int _c;
};

class D : public C, public B
{
public:
	int _d;
};

int main()
{
	D d;
	d.B::_a = 1;
	d.C::_a = 2;

	d._a = 0;
	d._b = 3;
	d._c = 4;
	d._d = 5;
	return 0;
}

菱形继承：

菱形虚拟继承：

此时：D对象继承的B,C中的变量——_a的位置发生了移动且只有一份；

而B,C里面原本是_a的位置现在存储着指针？这些代表着什么呢？

这里的A对象我们把它叫做：虚基类；在D对象中以公共的身份放到最下面被B,C访问

B和C的两个指针，指向的是一张表：叫虚基表。

虚基表中存的是偏移量：通过偏移量来计算虚基类的位置

 在STL库中也有对菱形虚拟继承的应用：

更复杂的菱形虚拟继承还有：

总结：在实践中可以设计使用多继承，但切记不要设计出菱形继承：太复杂，容易出错 

10继承的总结与反思

1. 很多人说C++语法复杂，其实多继承就是一个体现：

有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承
2. 多继承可以认为是C++的缺陷之一，很多后来的OO语言都没有多继承，如Java。

3组合与继承

public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。
组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象。

两者本质上都是一种复用

场景符合is-a的关系用继承；符合has-a的关系用组合；

两者都符合用组合：组合对内部实现细节不可见：低耦合

// Car和BMW Car和Benz构成is-a的关系
class Car {
protected:
	string _colour = "白色"; // 颜色
};

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; // 轮胎
};

 以上便是继承相关的知识：有错误欢迎在评论区指正，谢谢！！