• 继承【C++】

    文章目录

    继承的概念

    继承(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;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32

    继承后，父类Person的成员，包括成员函数和成员变量，都会变成子类的一部分，也就是子类Student和Teacher复用了父类Person的成员。

    继承的定义

    Person是父类，也称作基类。Student是子类，也称作派生类

    在这里插入图片描述

    继承方式和访问限定符

    访问限定符有以下三种：public访问、protected访问、private访问

    继承的方式也有类似的三种：public继承、protected继承、private继承

    继承基类成员访问方式的变化

    基类当中被不同访问限定符修饰的成员，以不同的继承方式继承到派生类当中后，该成员最终在派生类当中的访问方式将会发生变化。

    在这里插入图片描述

    总结：

    1. 基类private成员在派生类中无论以什么方式继承都是不可见的。
      这里所说的不可见，从语法上限制访问(类里面和类外面都不能用)。
      跟private访问限定符不一样，private访问限定符类外面不能使用，类里面可以使用
    //基类
class Person
{
private:
	string name = "张三";
};
//派生类
class Student :public  Person
{
public:
	void Print()
	{
		//在派生类当中访问基类的private成员
		cout << _name << endl;//error
	}
protected:
	int _stuid; // 学号
};

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    上述代码中 ，Student类继承了Person类，但是无法在Student类当中访问Person类当中的private成员_name。如果需要在派生类中能访问，就将private修改为protected

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

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

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

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

    默认继承方式

    在使用继承的时候也可以不指定继承方式，使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public。

    //基类
class Person
{
public:
	string _name = "张三"; //姓名
};
//派生类
class Student : Person //默认为private继承
{
protected:
	int _stuid;   //学号
};


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    在关键字为class的派生类当中，所继承的基类成员_name的访问方式变为private。

    //基类
class Person
{
public:
	string _name = "张三"; //姓名
};
//派生类
struct Student : Person //默认为public继承
{
protected:
	int _stuid;   //学号
};


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    在关键字为struct的派生类当中，所继承的基类成员_name的访问方式仍为public。

    基类和派生类对象赋值转换

    派生类对象 可以赋值给 基类的对象 / 基类的指针 / 基类的引用。这里有个形象的说法叫切片或者切割。寓意把派生类中父类那部分切来赋值过去。

    //基类
class Person
{
public:
	string _name; //姓名
	string _sex;  //性别
	int _age;     //年龄
};

//派生类
class Student : public Person  
{
protected:
	int _stuid;   //学号
};

int main()
{
	Student s;
	Person p = s; //派生类对象赋值给基类对象
	Person* ptr = &s;//派生类对象赋值给基类指针
	Person& ref = s; //派生类对象赋值给基类引用
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    派生类对象赋值给基类对象图示：

    在这里插入图片描述
    注意：基类对象不能赋值给派生类对象。

    继承中的作用域

    在继承体系中的基类和派生类都有独立的作用域。如果子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义

    例如：

    //父类
class Person
{
protected:
	int _num = 111;
};
//子类
class Student : public Person
{
public: 
	void fun()
	{
		cout << _num << endl;
	}
protected:
	int _num = 999;
};
int main()
{
	Student s;
	s.fun();//访问子类的_num
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23

    如果需要访问父类当中的_num成员，使用作用域限定符进行指定访问。

    //父类
class Person
{
protected:
	int _num = 111;
};
//子类
class Student : public Person
{
public: 
	void fun()
	{
		cout << Person::_num << endl;
	}
protected:
	int _num = 999;
};
int main()
{
	Student s;
	s.fun();//访问子类的_num
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23

    下面的代码，调用成员函数fun时将调用子类当中的fun，如果需要调用父类当中的fun，则使用作用域限定符指定类域。

    //父类
class Person
{
public:
	void fun(int x)
	{
		cout << x << endl;
	}
};
//子类
class Student : public Person
{
public:
	void fun(double x)
	{
		cout << x << endl;
	}
};
int main()
{
	Student s;
	s.fun(3.14);       //直接调用子类当中的成员函数fun
	s.Person::fun(20); //指定调用父类当中的成员函数fun
	return 0;
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

    上述代码，父类中的fun和子类中的fun不是构成函数重载，构成函数重载需要两个函数在同一作用域，而此时这两个fun函数并不在同一作用域。为了避免类似问题，实际在继承体系当中最好不要定义同名的成员。

    隐藏： 父子类域中，成员函数的函数名相同就构成隐藏，不用管函数参数，只需要看函数名即可

    派生类的默认成员函数

    默认成员函数，即我们不写编译器会自动生成的函数，类当中的默认成员函数有以下六个：

    在这里插入图片描述

    //基类
class Person
{
public:
	//构造函数
	Person(const string& 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;
	}
private:
	string _name;
};

//派生类
class Student : public Person
{
public:
	//默认构造函数
	//先父后子
	Student(const string name = "张三", int id = 0)
		:Person(name)//匿名对象 ，调用基类的构造函数初始化基类的成员
		, _id(id)
	{

	}
	//拷贝构造
	Student(const Student& s)
		:Person(s)
		, _id(s._id)
	{

	}
	//赋值
	Student& operator= (const Student& s)
	{
		if (this != &s)
		{
			Person::operator=(s);//?
			_id = s._id;
		}
		return *this;

	}
	~Student()
	{
		//显示调用父类析构，无法保证先子后父
		// Person::~Person();
		//在子类析构函数完成,就调用父类析构,这样就保证了先子后父
		
		delete _ptr;

	}
private:
	int _id;
	int* _ptr = new int;
};
int main()
{
	Student s1;
	Student s2(s1);
	Student s3("李四", 1);
	s1 = s3;
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88

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

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

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

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

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

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

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

    注意：
    1、派生类和基类的赋值运算符重载函数，函数名相同，但是在不同作用域，构成隐藏，所以在派生类当中调用基类的赋值运算符重载函数时，需要使用作用域限定符进行指定调用。
    2、由于多态的某些原因，任何类的析构函数名都会被统一处理为destructor();。因此，派生类和基类的析构函数也会因为函数名相同构成隐藏，若是我们需要在某处调用基类的析构函数，那么就要使用作用域限定符进行指定调用。
    3、在派生类的拷贝构造函数和operator=当中调用基类的拷贝构造函数和operator=的传参方式是一个切片行为，都是将派生类对象直接赋值给基类的引用。

    继承与友元

    友元关系不能继承
    即基类的友元可以访问基类的私有和保护成员，但是不能访问派生类的私有和保护成员。

    #include 
#include 
using namespace std;
class Student;
class Person
{
public:
	//声明Display是Person的友元
	friend void Display(const Person& p, const Student& s);
protected:
	string _name; //姓名
};
class Student : public Person
{
protected:
	int _id; //学号
};
void Display(const Person& p, const Student& s)
{
	cout << p._name << endl; //可以访问
	cout << s._id << endl; //err
}
int main()
{
	Person p;
	Student s;
	Display(p, s);
	return 0;
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30

    如果Display函数需要访问派生类Student的私有和保护成员，在派生类Student当中进行友元声明。

    //有元关系不能继承
class Student;
class Person
{
public: 
	friend void Display(const Person & p, const Student & s);
protected:
	string _name;
};

class Student :public Person
{
	friend void Display(const Person& p, const Student& s);
protected :
	int _id;
};


void Display(const Person& p, const Student& s)
{
	cout << p._name << endl;
	cout << s._id << endl;

}

int main()
{
	Person p;
	Student s;
	Display(p, s);
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32

    静态成员

    基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子类，都只有一个static成员实例

    //基类
class Person
{
public:
	Person()
	{
		_count++;
	}
protected :
	string _name;
public:
	static int _count;
};
 
int Person::_count = 0;
//派生类
class Student : public Person
{
protected :
	string _seminarCourse; //研究科目
};

int main()
{
	Person p;
	Student s1;
	Student s2;
	cout << Person::_count << endl;
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30

    菱形继承及菱形虚拟继承

    继承的方式

    单继承：一个子类只有一个直接父类时称这个继承关系为单继承。
    在这里插入图片描述
    多继承：一个子类有两个或两个以上直接父类时称这个继承关系为多继承。
    在这里插入图片描述

    菱形继承：菱形继承是多继承的一种特殊情况。
    在这里插入图片描述

    菱形继承有数据冗余和二义性的问题。

    //基类
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";//err
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33

    Assistant对象是多继承的Student和Teacher，而Student和Teacher当中都继承了Person，因此Student和Teacher当中都有_name成员，直接访问Assistant的_name成员，编译器不知道访问哪一个，会报错

    解决方案：

    //显示指定访问哪个父类的成员
a.Student::_name = "张三";
a.Teacher::_name = "李四";

    • 1
    • 2
    • 3

    上述解决方案可以解决二义性问题，但是不能解决数据冗余，在Assistant的对象在Person成员始终会存在两份。
    在这里插入图片描述

    菱形虚拟继承

    为了解决菱形继承的二义性和数据冗余问题，出现了虚拟继承。
    在Student和Teacher继承Person是使用虚拟继承，即可解决问题。
    在这里插入图片描述

    #include 
#include 
using namespace std;
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.Student::_name << endl;
	cout << a.Teacher::_name << endl;
	//解决了数据冗余
	cout << &a.Student::_name << endl;
	cout << &a.Teacher::_name << endl;

	return 0;
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36

    此时就可以直接访问Assistant对象的_name成员了，解决了二义性问题

    菱形虚拟继承原理

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33

    在这里插入图片描述
    D类对象当中各个成员在内存当中的分布情况如下：
    在这里插入图片描述
    菱形继承的数据冗余和二义性，本质上是D类对象当中含有两个_a成员。

    如果使用菱形虚拟继承时，菱形继承当中D类对象的各个成员在内存当中的分布情况。

    #include 
using namespace std;
class A
{
public:
	int _a;
};
class B : virtual public A
{
public:
	int _b;
};
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;
	d.C::_a = 2;
	d._b = 3;
	d._c = 4;
	d._d = 5;
	return 0;
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33

    在这里插入图片描述
    其中D类对象当中的_a成员被放到了最后，而在原来存放两个_a成员的位置变成了两个指针，这两个指针叫虚基表指针，它们分别指向一个虚基表。
    虚基表中包含两个数据，第一个数据是为多态的虚表预留的存偏移量的位置（这里我们不必关心），第二个数据就是当前类对象位置距离公共虚基类的偏移量。

    也就是说，这两个指针经过一系列的计算，最终都可以找到成员_a
    在这里插入图片描述

    若是将D类对象赋值给B类对象，在这个切片过程中，就需要通过虚基表中的第二个数据找到公共虚基类A的成员，得到切片后该B类对象在内存中仍然保持这种分布情况。

    D d;
B b = d; //切片行为


    • 1
    • 2
    • 3
  • 相关阅读:
    关于灭弧式智慧用电在养老机构的应用案例分析-安科瑞 蒋静
    迅为恩智浦iTOP-IMX6开发平台
    IDEA2022用maven创建的Servlet项目
    内网Windows Git Server部署
    线上验证真的就是点点点吗？
    软考高级系统架构设计师系列论文二十三：论数据中心集中存储架构
    使用xmlrpc连接操作odoo
    【百度智能体】零代码创建职场高情商话术助手智能体
    3d环形图开发（vue3+vite+ts）
    Abnova 鸡抗小鼠 IgG (H&L) 二抗（过氧化物酶）说明书
  • 原文地址：https://blog.csdn.net/qq_73478334/article/details/132524588