c++继承（下）

（1）继承与友元
（2）继承与静态成员
（3）多继承及其菱形继承问题
- [3.1 继承模型](#3.1 继承模型)
- [3.2 虚继承](#3.2 虚继承)
- [3.3 多继承中指针偏移问题](#3.3 多继承中指针偏移问题)
（4）继承和组合
（9）继承的总结

（1）继承与友元

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

cpp 复制代码

class student;//前置声明

class person
{
public:
	friend void func(person a,student b);//这里使用了student这个类，编译器只支持向下查找，必须前置声明
	void identify()
	{

	}
private:
	int _age;
	string _name = "zhangsan";
};

class student:public person
{
public:
	friend void func(person a, student b);
	void study()
	{

	}

private:
	int _stuid = 111;
};

void func(person a,student b)
{
	cout << a._name << ' ' << b._stuid << endl;
}
int main()
{
	person aa;
	student bb;
	func(aa,bb);
	return 0;
}

要想让两个类都可以使用func函数，这里的解决办法是同时声明友元即可。

（2）继承与静态成员

基类定义了static静态成员，则整个继承体系⾥⾯只有⼀个这样的成员。⽆论派⽣出多少个派⽣类，都只有⼀个static成员实例。

cpp 复制代码

class person
{
public:
	static int _count;

	void identify()
	{

	}
private:
	int _age;
	string _name = "zhangsan";
};

int person::_count = 1;

class student:public person
{
public:
	void study()
	{

	}
	
private:
	int _stuid = 111;
};

int main()
{
	person aa;
	student bb;

	person::_count++;

	cout << aa._count << endl;
	cout << bb._count << endl;

	cout << &aa._count << endl;
	cout << &bb._count << endl;
	return 0;
}

这份代码的运行结果：

我们可以看到count的地址没有发生变化，所以count只存在一份

（3）多继承及其菱形继承问题

3.1 继承模型

单继承：⼀个派⽣类只有⼀个直接基类时称这个继承关系为单继承

多继承：⼀个派⽣类有两个或以上直接基类时称这个继承关系为多继承，多继承对象在内存中的模型是，先继承的基类在前⾯，后⾯继承的基类在后⾯，派⽣类成员在放到最后⾯。

菱形继承：菱形继承是多继承的⼀种特殊情况。菱形继承的问题，从下⾯的对象成员模型构造，可以看出菱形继承有数据冗余和⼆义性的问题，在Assistant的对象中Person成员会有两份。⽀持多继承就⼀定会有菱形继承，像Java就直接不⽀持多继承，规避掉了这⾥的问题，所以实践中我们也是不建议设计出菱形继承这样的模型的。

单继承：

多继承：

菱形继承：

cpp 复制代码

class person
{
public:
	static int _count;

	void identify()
	{

	}

	string _name = "zhangsan";
private:
	int _age;
};


class student:public person
{
public:
	void study()
	{

	}
private:
	int _stuid = 111;//学号
};

class teacher:public person
{
public:
	void teach()
	{

	}
private:
	string teaid;//教师编号
};

//老师助理,这里的意思是教师助理既作为教授的学生，又作为学校里的老师
class assistant:public student,public teacher
{

};

//这里就是一个菱形继承
int main()
{
	assistant a;
	//a._name = "tsy";//这里具有二义性

	a.student::_name = "张三";
	a.teacher::_name = "李四";//这样指定是可以的

	//并且person在a里是有两份的，数据冗余不能解决
	//并且这里是有两个名字的，一个作为学生，一个作为老师，这样是不太好的，person里的名字应该是类似于身份证上的名字，我们最好不好去更改
	return 0;
}

3.2 虚继承

cpp 复制代码

//这里引入了virtual,它被使用于产生数据冗余的地方，例如person会在student与teacher里各存一份，这里会产生数据冗余
class person
{
public:
	static int _count;

	void identify()
	{

	}

	string _name = "zhangsan";
private:
	int _age;
};


class student :virtual public person
{
public:
	void study()
	{

	}
private:
	int _stuid = 111;//学号
};

class teacher :virtual public person
{
public:
	void teach()
	{

	}
private:
	string teaid;//教师编号
};

//老师助理,这里的意思是教师助理既作为教授的学生，又作为学校里的老师
class assistant :public student, public teacher
{

};

int main()
{
	assistant a;
	a._name = "tsy";//这里就可以使用了
	//这里给定的name就类似于身份证上的名字
	return 0;
}

virtual使用于产生数据冗余的地方，并且不可能单独出现

3.3 多继承中指针偏移问题

c 复制代码

class Base1 
{
public: 
	int _b1;
};
class Base2 
{ 
public: 
	int _b2; 
};
class Derive : public Base1, public Base2 
{ 
public: 
	int _d;
};

int main()
{
	Derive d;
	Base1* p1 = &d;
	Base2* p2 = &d;
	Derive* p3 = &d;
	return 0;
}
//A：p1 == p2 == p3  B：p1 < p2 < p3  C：p1 == p3 != p2  D：p1 != p2 != p3

所以答案选择 C

（4）继承和组合

• public继承是⼀种is-a的关系。也就是说每个派⽣类对象都是⼀个基类对象。

• 组合是⼀种has-a的关系。假设B组合了A，每个B对象中都有⼀个A对象。

• 继承允许你根据基类的实现来定义派⽣类的实现。这种通过⽣成派⽣类的复⽤通常被称为⽩箱复⽤(white-box reuse)。术语"⽩箱"是相对可视性⽽⾔：在继承⽅式中，基类的内部细节对派⽣类可⻅。继承⼀定程度破坏了基类的封装，基类的改变，对派⽣类有很⼤的影响。派⽣类和基类间的依赖关系很强，耦合度⾼。

• 对象组合是类继承之外的另⼀种复⽤选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接⼝。这种复⽤⻛格被称为⿊箱复⽤(black-box reuse)，因为对象的内部细节是不可⻅的。对象只以"⿊箱"的形式出现。组合类之间没有很强的依赖关系，耦合度低。优先使⽤对象组合有助于你保持每个类被封装。

• 优先使⽤组合，⽽不是继承。实际尽量多去⽤组合，组合的耦合度低，代码维护性好。不过也不太那么绝对，类之间的关系就适合继承(is-a)那就⽤继承，另外要实现多态，也必须要继承。类之间的关系既适合⽤继承(is-a)也适合组合(has-a)，就⽤组合。

cpp 复制代码

// Tire(轮胎)和Car(⻋)更符合has-a的关系
class Tire {
protected:
	string _brand = "Michelin"; // 品牌
	size_t _size = 17;
	// 尺⼨
};
class Car {
protected:
	string _colour = "⽩⾊";
	// 颜⾊
	string _num = "陕ABIT00";
	// ⻋牌号
	Tire _t1;
	// 轮胎
	Tire _t2;
	// 轮胎
	Tire _t3;
	// 轮胎
	Tire _t4;
	// 轮胎
};
class BMW : public Car {
public:
	void Drive() { cout << "好开-操控" << endl; }
};
// Car和BMW/Benz更符合is-a的关系
class Benz : public Car {
public:
	void Drive() { cout << "好坐-舒适" << endl; }
};
template<class T>
class vector
{};
// stack和vector的关系，既符合is-a，也符合has-a
template<class T>
class stack : public vector<T>
{};
template<class T>
class stack
{
public:
	vector<T> _v;
};
int main()
{
	return 0;
}

（9）继承的总结

1、继承在生活中常见的只有公有继承，所以公有继承一定要弄明白。

2、派生类的默认成员函数与之前学的普通类的是一样的，如果我们需要显示的去写构造函数等等，需要将父类作为一个整体，去调用父类的构造等函数。

3、继承这块是先构造父类再构造子类，析构是先析构子类再析构父类

4、菱形继承目前阶段我们把握不住，并且用到的场景也可以通过其他方式解决，所以最好不要写菱形继承，但是学校可能会考，所以也是需要简单了解下的。

5、如果我们需要设计一个不能被继承的类，我们有两种方式：

（1）将基类构造函数变为私有

（2）final

cpp 复制代码

class Base final
{
public:
void func5() { cout << "Base::func5" << endl; }
protected:
int a = 1;
private:
// C++98的⽅法
/*Base()
{}*/
};
class Derive :public Base
{
void func4() { cout << "Derive::func4" << endl; }
protected:
int b = 2;
};
int main()
{
Base b;
Derive d;
return 0;
}

这一点只做了解