c++进阶(继承)

目录

🏀.继承的概念及定义

⛹.继承方式访问变化

🐱‍🏍Summary：

🏀.基类派生类赋值转换

 🏀.继承中的作用域

 🏀.派生类的默认成员函数

 🏀.友元与继承/静态成员继承

🏀.菱形继承及虚拟继承

Consider：菱形继承会产生什么问题？产生的问题怎么去解决~

🏀虚拟继承

🐱‍🏍虚拟继承方式

🚀Summary

---

csdn主页

🏀.继承的概念及定义

    听到继承这个关键(inheritance)词我们不难想到生活中有不少这样的例子，孩子继承家业~学生继承老师的技能，这在c++中是一样的，c+设计者智慧有可能也是来自生活吧。在c++当中继承是可以让类代码可以复用的高效手段，它允许我们在原有的类上进行有效的拓展，而且保持原来的类性质不发生改变，增加一些功能，而新产生的类我们就叫它派生类也可以叫做子类对象。我们之前学习的函数的重载就达到了高效的方式，而继承主要就是面对对象来使用的~我们看一下下面这段代码

我们看到在类Son中我们并没有定义string变量name但是却在Son类定义中却可以给出这样一个变量，这及为继承的本质。

⛹.继承方式访问变化

• 继承方式：继承方式分为三种，分别对应公有继承(public),保护继承(protected),私有继承(private).这三种继承方式只对派生类起作用。在基类当中变量的访问方式与继承方式又构成了几种形式。

类成员/继承方式	public	protected	private
基类public成员	子类public成员	子类protected成员	子类private成员
基类protected成员	子类public成员	子类protected成员	子类private成员
基类private成员	子类不可用	子类不可用	子类不可用

🐱‍🏍Summary：

    1.基类private成员无论怎么继承在子类当中都是不可见的，其意思也就是基类的private成员会被继承过来，不过c++限制了在子类当中或者在类外都不可以再去访问它。

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

    3.实际上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected > private。

    4.使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。

    5.在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡使用 protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。

🏀.基类派生类赋值转换

•     派生类对象可以再赋值给基类的对象/指针/引用。我们通常叫它切片，或者切割~
•     基类对象不可以赋值给派生类对象~
•     基类的指针可以通过强制类型转换赋值给派生类对象的指针，不过需要基类对象的指针是指向派生类的对象是安全的。

 派生类对象的age变量不可赋值给基类对象。属于被切割了~

int main()
{
	Son s1;
	Father f=s1;
	Father* f1 = &s1;
	Father& f2 = s1;

	//基类不可再赋值给派生类
	s1 = f;
	//这种情况是可以的
	Son*s1 = (Son*)f1;
	return 0;
}

 🏀.继承中的作用域

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

    🏀.派生类的默认成员函数

    六个默认成员函数我们已经有过了解在继承这一块也会用的到，在派生类当中六个默认函数也会生成。

1. 派生类构造函数必须调用基类的构造函数初始化基类的那一部分成员，如果基类没有默认的构造函数，那么必须在派生类构造函数初始化列表显示调用。
2. 派生类的拷贝构造函数必须调用基类的拷贝构造函数
3. operator=同上
4. 派生类析构函数会在调用完自己的析构函数之后再去调用基类的析构函数，清理成员函数，这样保证派生类对象函数被清理之后再清理基类的成员
5. 派生类先调用基类构造函数在调用派生的
6. 派生类对象先调用派生析构函数再调用基类的

class Person
{
public:
	Person(const char* name = "peter")
		: _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(const char* name, int num)
		: Person(name)
		, _num(num)
	{
		cout << "Student()" << endl;
	}

	Student(const Student& s)
		: Person(s)
		, _num(s._num)
	{
		cout << "Student(const Student& s)" << endl;
	}

	Student& operator = (const Student& s)
	{
		cout << "Student& operator= (const Student& s)" << endl;
		if (this != &s)
		{
           //这里我们要指定作用调用
			Person::operator =(s);
			_num = s._num;
		}
		return *this;
	}

	~Student()
	{
		cout << "~Student()" << endl;
	}
protected:
	int _num; //学号
};
void Test()
{
	Student s1("jack", 18);
	Student s2(s1);
	Student s3("rose", 17);
	s1 = s3;
}

 🏀.友元与继承/静态成员继承

•     友元关系不能被继承，基类中的友元函数不可以被继承到派生类当中。
•     静态成员被继承之后一直是这一个成员，以后的继承都只是这一个继承的成员

🏀.菱形继承及虚拟继承

单继承：一个派生类继承一个基类。

多继承：一个派生类继承多个基类~

菱形继承：多继承的特殊情况~

Consider：菱形继承会产生什么问题？产生的问题怎么去解决~

     我们知道在祖先类当中被继承下来两份变量到腰部的派生类当中，最后一个派生类 又继承了腰部派生类的成员，这样就会重复继承了，就会产生二义性。

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._name = "Halif";
}

    以上代码段由于菱形继承就产生了二义性，因为这样a.所指定的不知道是指向哪个所继承的。编译器直接就会报错。

这样产生的二义性我们可以使用指定作用域方式勉强解决~

Assistant a;
	a.Student::_name = "peter";
	a.Teacher::_name = "Halif";

不过主要解决二义性与数据沉余的方式我们可以通过虚继承来解决。

🏀虚拟继承

    我们定义了如下菱形继承👇

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

这里使用了指定作用域方式来解决二义性问题，也就是编译器可以编译了，但是不代表没有问题，

我们可以看一下他们的内存空间是怎么存储的。

 我们看到所定义的d.B::_a.的内存空间并没有和d.C::_a连续存储着。按我们之前所学的知识，自定义类型的变量都在栈开空间，那么他们的地址应该是按着定义的先后在栈上连续的~~~我现在叫它数据沉余问题。也就是它的第二次变量赋值并没有改变原来的变量。这里我们就用到虚拟继承来解决这个问题。

🐱‍🏍虚拟继承方式

虚拟继承在腰部的位置添加virtual关键字。

class B:virtual public A
{
public:
	int _b;
};

这样可以很好的解决问题。

 那么关于虚拟继承的底层原理是这样解释的，我们看到上面的3   4  并没有连续着储存而是中间跳过了几个字节。其实原理是这样的~~~~这里是通过了B和C的两个指针，指向的一张表。这两个指

针叫虚基表指针，这两个表叫虚基表。虚基表中存的偏移量。通过偏移量可以找到下面的 A 。

🚀Summary

    多继承方式虽然方便但是，不要盲目去使用更不要设计出菱形继承，有了菱形继承问题就会随之而来。在达到高效的目的时还有另一种结合方式叫做组合。比如飞机的组合，飞机有发动机，有机翼，有控制系统，每个部件都来自不同的地方，这样组合起来就达成了一个完整品。继承和组合的最大不同体现在了每个类的封装性，继承就会破坏基类的封装性，依赖性，耦合性非常高。组合没有太大的依赖性，而且封装性比较高。