C++系列-继承补充

最新推荐文章于 2024-10-06 10:17:48 发布

羽晨同学

最新推荐文章于 2024-10-06 10:17:48 发布

阅读量933

点赞数 13

分类专栏： C++ 文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/in_seattle/article/details/142678150

版权

C++ 专栏收录该内容

43 篇文章 0 订阅

订阅专栏

🌈个人主页：羽晨同学

💫个人格言:“成为自己未来的主人~”

继承和友元

友元关系不能继承，父亲的朋友不能是你的朋友

比如在这个例子当中：

class Student;
class Person
{
public:
	friend void Display(const Person& p, const Student& s);
protected:
	string _name;//姓名
};
class Student :public Person
{
public:
	//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);
	return 0;
}

这个访问p._name是没有问题的，但是访问s._stuNum是会发生报错的，因为友元函数不能被继承，所以基类也就不能访问子类的私有和保护的成员。

那怎么样才能解决这个问题呢？

答案其实很简单，那就是：让孩子自己和朋友培养关系，也就是说，在派生类中再次写一次友元函数的声明。

class Student;
class Person
{
public:
	friend void Display(const Person& p, const Student& s);
protected:
	string _name;//姓名
};
class Student :public Person
{
public:
	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);
	return 0;
}

这样子，就不会发生报错了。

继承和静态成员

基类定义的静态成员，那么不管是基类还是派生类都只有这样一个静态成员，也就是说，静态成员是不会继承的。具体我们来看下面的代码：

class Person
{
public:
	Person()
	{
		++_count;
	}
protected:
	string _name;
public:
	static int _count;
};
int Person::_count = 0;
class Student :public Person
{
protected:
	int _stuNum;
};
int main()
{
	Person p;
	Student s;
	cout << &Person::_count << endl;
	cout << &Student::_count << endl;
	return 0;
}

我们可以看到的是，不管是基类的_count还是派生类的_count，它们的地址是相同的。所以，我们可以得到的是，静态成员修饰的变量或者函数是不会参与继承的。

菱形继承和菱形虚拟继承

单继承

一个子类只有一个父类，叫做单继承。

多继承

一个子类有多个父类，这是多继承

菱形继承

菱形继承是多继承的一种特殊情况。

菱形继承的问题：数据冗余和二义性。怎么说呢，其实看上面的图，我们可以看到，Person的信息其实被Student和Teacher继承了一次，说明在Student和Teacher中都有Person的信息，当Assistant继承Student和Teacher的时候，继承了两次Person的信息，这就造成了数据的冗余和二义性。

数据冗余和二义性

你看，在下面代码中同时存在数据冗余和二义性的问题：

class Person
{
public:
	string _name;
	int _id;
	int _tel;
	int _adress;
};
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";

	return 0;
}

当我们运行这个代码的时候，是会报错的，原因是因为并不知道_name具体指向的是什么，其实这个很好解决，我们只要在前面加上特定类域的声明就可以了.比如：

int main()
{
	Assistant a;
	a.Teacher::_name = "peter";
	a.Student::_name = "jijiao";
	return 0;
}

但是这样子的话，其实数据冗余的问题是没有办法解决的，那我们应该怎么处理呢，这个时候就需要用到虚拟继承了。

虚拟继承是可以解决二义性和数据冗余的问题的，我们只要在第一次继承的前面加上virtual就可以避免这些问题。

class Person
{
public:
	string _name;
	int _id;
	int _tel;
	int _adress;
};
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";
	return 0;
}

这样，这个代码就没问题了。

很多人说C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂，所以一般不建议设计出多继承，一定不要涉及出菱形继承，否则在复杂度及性能上都有问题。

多继承可以认为是C++的缺陷之一。

在实践中，尽可能的使用多继承，而不是菱形继承。

继承和组合

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

class Tire
{
protected:
	string _brand = "Michelin";//品牌
	size_t _size = 17;//尺寸
};
//组合
class Car
{
protected:
	string colour = "白色";//颜色
	string _num = "陕ABIT00";//车牌号
	Tire _t;
};

你看，在这个里面，轮胎和车并不是is-a的关系，不能说轮胎是车，也不能说车是轮胎，只能说车里面有轮胎。这个就是组合。

在代码关系当中，代码和代码之间的耦合度越低越好，所以，我们尽量使用组合，而不是继承。