【C++】继承基础知识一遍过

目录

一，概念

二，继承定义

1. 继承格式 

2. 访问限定符与继承方式的关系

3. 继承父类成员访问方式的变化

小结： 

三. 父类与子类对象赋值转化

四，继承作用域

1.特点 

2. 测试题

五，派生类不一样的默认成员函数

1.构造函数

2.拷贝构造

3.赋值符号重载

4.析构函数

5. 小结

六，友元与继承

七，继承与静态成员

2.思考：如何制作一个无法被继承的类

八，菱形继承与虚拟菱形继承

1. 菱形继承的问题

2. 虚拟继承解决方案

3. 虚拟继承底层细节 

九，继承与组合

总结：

结语

一，概念

基于原有类的一般叫做基类(base_class)，我感觉叫他为—— 父类 ，这更容易理解。

#include 
#include 
 
using namespace std;
 
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();
	t.Print();
	return 0;
}

二，继承定义

1. 继承格式 

下面我们看到Person是父类，也称作基类。 Student是子类，也称作派生类  

2. 访问限定符与继承方式的关系

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

3. 继承父类成员访问方式的变化

小结： 

1. 父类private成员在派生类中无论以什么方式继承都是不可见的。这里的 不可见是指父类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。

2. 父类private成员在派生类中虽然被继承了，但父类私有是不可见的（因为权限问题），如果父类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。 可以看出保护成员限定符是因继承才出现的。

 3. 子类访问权限 =   修饰符与继承方式的最小权限 ，如：修饰符是private,继承方式是public最终权限是private。 权限从大到小是：public > protected > private

4.在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡使用protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。所以基本上，常用的处理 继承方式：public。 处理成员变量，函数: 用public / protected

三. 父类与子类对象赋值转化

class Person
{
protected:
	string _name; // 姓名
	string _sex;
	int _age; // 年龄
};
class Student : public Person
{
public:
	int _No; // 学号
};
 
void Test()
{
	Student sobj;
	// 1.子类对象可以赋值给父类对象/指针/引用
	Person pobj = sobj;
	Person* pp = &sobj;
	Person& rp = sobj;
 
	//2.父类对象不能赋值给子类对象
	// sobj = pobj;
 
 
	// 3.父类的指针可以通过强制类型转换赋值给子类的指针
	pp = &sobj;
	Student * ps1 = (Student*)pp; // 这种情况转换时可以的。
	ps1->_No = 10;
 
	// 父类利用指针强转给子类指针
	pp = &pobj;
	Student* ps2 = (Student*)pp; // 这种情况转换时虽然可以，但是会存在越界访问的问题
	ps2->_No = 10;   
}

我们可以发现：

1. 父类对象不能赋值给子类对象

2. 父类对象地址强转为子类地址，最终在子类访问其新成员时会发生越界报错。

四，继承作用域

1.特点 

2. 测试题

class A
{
public:
 void fun()
 {
 cout << "func()" << endl;
 }
};
 
class B : public A
{
public:
 void fun(int i)
 {
 A::fun();
 cout << "func(int i)->" << i << endl;
 }
}；
 
void Test()
{
 B b;
 b.fun();
};
// 不定向选择：
// A: 子父func构成重载
// B: 子父func构成隐藏
// C: 程序报错
// D：以上都不对
 

答案：BC 。B,首先是子父类拥有同名成员函数，构成隐藏。C，因为子类对父类同名函数的隐藏，导致无法找到匹配fun函数，因此报错。

五，派生类不一样的默认成员函数

 这是本次的实验代码，经过这次的学习，我们来补充这个派生类。

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:
	// 构造函数
protected:
	int _num; //学号
};
 
void Test()
{
	Student a;
	int x = 1;
}
 
int main()
{
	Test();
	return 0;
}

1.构造函数

 我们先不写构造函数，我们查看默认构造函数会发生什么事？

 很明显：默认构造函数，父类会调用其自己的构造函数；子类也是调用其自己的构造函数，没有，则编译器自动生成构造函数。（总之：各自构造各自的）且构造顺序为先父类——>子类。

    // 构造函数
	Student(const char* name ,const int num = 0)
		:Person(name)
		,_num(num)
	{}

2.拷贝构造

 思路：父类数据，通过父类的隐式转化。

    // 拷贝构造
	Student(const Student& s1)
		:_num(s1._num)
		, Person(s1)    // 通过子类向父类的强转化
	{
		cout << "Student(const Student& )" << endl;
	}

3.赋值符号重载

 思路：调用父类赋值符号重载，再给子类成员变量赋值。

    // 赋值符号重载
	Student& operator=(const Student& s1)
	{
		cout << "operator=" << endl;
		if (this != &s1)
		{
			Person::operator=(s1);
			_num = s1._num;
		}	
		return *this;
	}

 补充：如果子类成员变量不需要深拷贝，其实不需要写拷贝，赋值符号重载函数，因为父类有这两个函数。

4.析构函数

 这个没啥好说的，父子类各自调用各自的析构函数。

析构顺序：子类先析构，当子类析构完成后再调用父类析构。

5. 小结

1. 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。

2. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。

3. 派生类的operator= 必须要调用基类的operator=完成基类的复制。

4. 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。

5. 派生类对象初始化先调用基类构造再调派生类构造。

6. 派生类对象析构清理先调用派生类析构再调基类的析构。

7. 因为后续一些场景析构函数需要构成重写，重写的条件之一是函数名相同(这个我们后面会讲 解)。那么编译器会对析构函数名进行特殊处理，处理成destrutor()，所以父类析构函数不加virtual的情况下，子类析构函数和父类析构函数构成隐藏关系。

六，友元与继承

如果大家对友元陌生了，可以看小博主这篇文章回忆：详解C++类和对象（下篇）——用代码实践功能_花果山~~程序猿的博客-CSDN博客

结论：派生类不能继承父类的友元关系，换句话说，友元函数或者友元类无法直接获取派生类的私有或者保护成员变量及函数。  

示例代码： 

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;
}
void main()
{
 Person p;
 Student s;
 Display(p, s);
}

友元关系无法继承，所以在派生类中如果需要友元关系，需要重新声明友元关系。 

七，继承与静态成员

静态成员变量与函数相关基础知识详解C++类和对象（下篇）——用代码实践功能_花果山~~程序猿的博客-CSDN博客

现象结论：基类定义了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; // 研究科目
};
 
void TestPerson()
{
	Student s1;
	Student s2;
	Student s3;
	Graduate s4;
	cout << " Person接口 人数 :" << Person::_count << endl;
	Student::_count = 666; // 在Student类，访问Person类中静态成员变量，并且设置该静态成员变量
	cout << " Person接口 人数 :" << Person::_count << endl;
	cout << " Student接口 人数 :" << Student::_count << endl;
	cout << " Graduate接口 人数 :" << Graduate::_count << endl;
}

2.思考：如何制作一个无法被继承的类

 思路：对构造与析构函数其中一个私有化。

class  Person
{
public:
	~Person()	
	{}
private:
	Person()
	{}
    
	int _age = -1;
	char* _name;
};
 
class Student : public Person
{
private:
	int _score;
};
 
 
void TestPerson()
{
	Student a;
    Person  a1; // 当然，父类自己也实例不了对象了
}

诺，这样子类就调不动父类。但，同时父类自己也实例不了对象，你真的，哭死我了。

解决方案：创建一个静态成员函数，让类外就可以实例化对象，这样就绕开了创建对象时系统调用构造函数这条路。

    // 单纯的成员函数也不行，因为对象都没有你告诉咋调函数。
	static Person create_Person()
	{
		return Person();
	}

八，菱形继承与虚拟菱形继承

1. 菱形继承的问题

导致内存浪费！！！

2. 虚拟继承解决方案

实验代码：

class A
{
public:
	int _a;
};
 
// class B : public A
class B : virtual public A
{
public:
	int _b;
};
 
// class C : public A
class C : virtual public A
{
public:
	int _c;
};
 
class D : public B, public C
{
public:
	int _d;
};
 
int main()
{
	D d;
	d.B::_a = 1;
	cout << &(d.B::_a) << endl;
 
	d.C::_a = 2;
	cout << &(d.C::_a) << endl;
 
	d._b = 3;
	d._c = 4;
	d._d = 5;
	return 0;
}

虚拟菱形继承，让一个类通过虚拟继承从多个基类继承时，只会保留一个共同的基类子对象，避免了出现多个相同的基类子对象。

诺，数据冗余：

3. 虚拟继承底层细节 

 这里会提到内存大小端知识，可以参见本文【C语言】整，浮点型数据存储，大小端。细节拉满！！_小端浮点数组_花果山~~程序猿的博客-CSDN博客

 原理精简图：

 补充：如果多个相同虚拟菱形继承类的对象，其访问的偏移表是同一套。如：D是一个虚拟菱形继承的类，则D   d1, d2, d3....., d1,d2,d3都是访问同一套偏移表。从这里我们也可以发现，虚拟菱形继承为了解决数据冗余和二义性的问题，需要访问偏移表，但毫无疑问，这会造成性能损失。

4. 菱形继承给不知死活的小白，一点小小的震撼！

 问：请解释打印顺序

using namespace std;
class A {
public:
	A(const char* s) { cout << s << endl; }
	~A() {}
};
 
class B :virtual public A
{
public:
	B(const char* s1, const char* s2) :A(s1) { cout << s2 << endl; }
};
 
class C :virtual public A
{
public:
	C(const char* s1, const char* s2) :A(s1) { cout << s2 << endl; }
};
 
class D :public B, public C
{
public:
	D(const char* s1, const char* s2, const char* s3, const char* s4) : B(s1, s2), C(s1, s3), A(s1)
	{
		cout << s4 << endl;
	}
};
 
 
int main() 
{
	D* p = new D("class A", "class B", "class C", "class D");
	delete p;
	return 0;
}

解析：首先是构造函数先构造父类，所以A类先被构造，然后根据继承先后

随后就是B类构造, 然后是C类，最后就是D类。整个过程A类只被调用一次。（我刚开始看到的时候，人都有点懵了） 

九，继承与组合

继承是一种关系，其中一个类（称为子类或派生类）可以继承另一个类（称为父类或基类）的属性和方法。

组合是另一种关系，其中一个类（称为容器类）包含另一个类的对象（称为成员类）。容器类通过创建成员类的对象来使用成员类的属性和方法。

（就像之前我们所学的STL中vector类这样的容器，里面放着string类）

总结：

  很多人说C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设计出菱形继承。否则在复杂度及性能上都有问题。多继承可以认为是C++的缺陷之一，很多后来的OO语言都没有多继承，如Java。

结语

   本小节就到这里了，感谢小伙伴的浏览，如果有什么建议，欢迎在评论区评论，如果给小伙伴带来一些收获请留下你的小赞，你的点赞和关注将会成为博主创作的动力