【C++】继承

最新推荐文章于 2024-09-26 21:10:57 发布

小小小汐-

最新推荐文章于 2024-09-26 21:10:57 发布

阅读量1.3k

点赞数 56

文章标签： c++

本文链接：https://blog.csdn.net/2301_79789645/article/details/136839808

版权

本文详细解析了C++中的继承概念、定义、访问控制、对象转换、作用域规则、派生类特性、友元与静态成员以及复杂继承结构（包括菱形继承和虚拟继承）。作者强调了避免多继承和菱形继承的重要性，提倡使用组合而非继承来提高代码的可维护性。

摘要由CSDN通过智能技术生成

1. 继承的概念和定义

a. 概念

继承机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。

b. 定义

(1) 定义格式

举例

class People //可以被成为 父类 或者是 基类
{
protected: 
	int _a = 4;
	int _b = 5;
public:
	void Print()
	{
		cout << _a << " " << _b << endl;
	}
};
class Student : public People  //可以被成为 子类 或者 派生类
{
private:
	int _c;
};

(2) 继承方式和访问限定符

继承方式：

private 继承
public 继承
protected 继承

访问限定符：

private 访问
public 访问
protected 访问

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

注意：

1. 基类private成员在派生类中无论以什么方式继承都是不可见的(即在派生类里面不可以访问)

2. 基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected

3. 基类的其他成员在子类的访问方式 = Min(成员在基类的访问限定符，继承方式)，比较方式：public > protected > private

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

5. 在实际运用中一般使用都是public继承

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

注意：

派生类转换成基类的时候，不会生成临时变量，而是调用基类的拷贝构造

代码举例
class People
{
protected: 
	int _a = 4;
	int _b = 5;
public:
	void Print()
	{
		cout << _a << " " << _b << endl;
	}
};
class Student : public People
{
private:
	int _c;
};
void test1()
{
	Student tt;
	People& t = tt; //这种写法是正确的
}
如果生成临时变量，这里会报警告（发生了权限的放大）

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

画图分析

3. 继承中的作用域

在继承体系中基类和派生类都有独立的作用域
子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义（在子类成员函数中，可以使用基类::基类成员显示访问）

代码举例1

class People
{
protected: 
	int _a = 4;
	int _b = 5;
};
class Student : public People
{
private:
	int _a = 10;
public:
	void Print()
	{
		cout << _a << endl; //调用的是 派生类 的变量
		cout << People::_a << endl;//调用的是 基类 的变量
	}
};
void test1()
{
	Student tt;
	tt.Print();
}

运行结果：

代码举例2
class People
{
protected: 
	int _a = 4;
	int _b = 5;
public:
	void Print()
	{
		cout << _a << " " << _b << endl;
	}
};
class Student : public People
{
private:
	int _c = 10;
public:
	void Print()
	{
		cout << _c << endl;
	}
};
void test1()
{
	Student tt;
	tt.Print();  //调用的是派生类的函数
  tt.People::Print(); //调用的是基类的函数
}
运行结果：

分析：

这两个构成隐藏（注意：一定不能是重载，至少重载函数是需要在同一作用域的）

需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏，且隐藏只存在于子类和父类之中
注意在实际中在继承体系里面最好不要定义同名的成员

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

在派生类中，成员函数的实现：

派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员（即基类成员变量的初始化不可以在派生类中实现）。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用

代码举例

class People
{
public: 
	People(int _a,int _b)
		:_a(_a)
		,_b(_b)
	{
		cout << "People()" << endl;
	}
protected:
	int _a;
	int _b;
};
class Student : public People
{
private:
	int _c;
public:
	Student()
		:_c(10)  
		, People(33,34)  //调用 父类 的构造函数
	{
		cout << "Student()" << endl;
	}
};
void test1()
{
	Student tt;
}

运行结果：

我们可以知道：

编译器会先调用父类的构造函数，再调用子类的构造函数

派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化
派生类的operator=必须要调用基类的operator=完成基类的复制
派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员（即先调用派生类的析构函数，再调用基类的构造函数）
派生类对象初始化先调用基类构造再调派生类构造
编译器会对析构函数名进行特殊处理，处理成destrutor()，所以父类析构函数不加virtual的情况下，子类析构函数和父类析构函数构成隐藏关系

5. 继承与友元

友元不能被继承（即父类定义的友元函数可以访问父类的成员变量，但是不能访问子类的私有或者保护成员变量）

6. 继承与静态成员

静态成员是不会被继承的，但是它既属于父类也属于子类

代码举例1（静态成员变量）

 namespace lhy
{
	class People
	{
	public: 
		static int a;
	};
   int People::a = 10;
	class Student : public People
	{

	};
	void test1()
	{
		Student tt;
		cout << People::a << endl;
		cout << Student::a << endl;
	}
}

运行结果：

代码举例2（静态成员函数）

namespace lhy
{
	class People
	{
	public: 
		People()
		{
			a++;
		}
		static int get_number()
		{
			return a;
		}
	protected:
		static int a;
	};
   int People::a = 0;
	class Student : public People
	{
	};
	void test1()
	{
		Student tt;
		People s1;
		People s2;
		cout << Student::get_number() << endl;
	}
}

运行结果：

7. 复杂的菱形继承及菱形虚拟继承

a. 继承方式

单继承：一个子类只有一个直接父类时称这个继承关系为单继承

多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承

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

对于菱形继承，容易出现数据冗余和二义性的问题

代码举例
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;
};
void test()
{
	D d;
	d.B::_a = 4;
	d.C::_a = 5;
}
注意：

这里的_a 一定要指明作用域才可以使用（在 B类和 C类中都有_a）

并且这里的两个类中的_a不是同一个

b. 虚拟继承

面对菱形继承带来的问题，虚拟继承可以解决

代码举例
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;
};
void test()
{
	D d;
	d._a = 10;
}
注意：

这里的_a只有一个，无论是B类里面的_a，还是C类里面的_a，都是同一个

c. 虚拟继承解决数据冗余和二义性的原理

代码举例
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._a = 10;
	d._b = 3;
	d._c = 4;
	d._d = 5;
	return 0;
}
我们会发现，在 B类和 C类的部分还除了内部的成员变量，还存了别的数据，实际上那是一块地址

拿B类举例：

14 00 00 00 ：转化成10进制就是20

20 我们可以理解成偏移量

所以：

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

对于初始化的顺序，先声明就先初始化（如这里初始化顺序：

A B C D）

B C 初始化的顺序先后看这里：