C++ 继承

已于 2025-03-17 13:58:30 修改
阅读量940 收藏 17
点赞数 12
文章标签： c++ 开发语言
于 2025-03-17 12:43:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_74951730/article/details/146312170
版权

C++ 继承

目录

引言

在本篇博客中，我们将深入探讨 C++ 中的继承机制，涵盖继承的基本概念、访问控制、派生类的构造与析构、多继承及其潜在问题（如菱形继承），以及继承与组合的区别与应用场景。通过丰富的代码示例和详细的解释，我们将帮助你全面理解 C++ 继承的方方面面，并掌握如何在实际项目中合理使用继承来构建高效、可维护的代码结构。

1. 继承的概念及相关知识

1.1 概念

继承(inheritance)机制是⾯向对象程序设计使代码可以复⽤的最重要的手段，它允许我们在保持原有类特性的基础上进⾏扩展，增加方法(成员函数)和属性(成员变量)，这样产生新的类，称派生类。继承呈现了⾯向对象程序设计的层次结构，体现了由简单到复杂的认知过程。

需要注意的是：继承是形象的说法，不会真把基类的成员拷贝一份放到派生类。

1.2 定义

格式如图：Student 是子类/派生类 ， Person 是父类/基类。

继承方式和访问限定符一样也分为三种，public继承、protected继承、private继承。

在这里插入图片描述

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

基类成员访问方式 / 派生类继承方式派生类public继承派生类protected继承派生类private继承
基类的public成员派生类的public成员派生类的protected成员派生类的private成员
基类的protected成员派生类的protected成员派生类的protected成员派生类的private成员
基类的private成员在派生类中不可见在派生类中不可见在派生类中不可见
  1. 基类private成员在派生类中无论以什么方式继承都是不可见的。这⾥的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。不过派生类还是可以通过间接使用到基类的私有成员。
  2. 基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。
  3. 由上表可得：基类成员在派生类的访问方式 == Min(基类成员访问限方式，派生类继承方式)，Min的比较策略是public > protected > private。
  4. 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。
  5. 在实际运用中一般使用都是public继承，几乎很少使用protected / private继承，也不提倡使用protected / private继承，因为protected / private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。

1.4 继承类模版

基类是类模版时，如果派生类成员要调用基类的成员函数，需要指定类域，否则会编译报错error C3861: “push_back”: 找不到标识符。因为派生类显式实例化时stack<int>，也实例化了基类vector<int>，但是模版是按需实例化，push_back等成员函数未实例化，所以编译时找不到。

代码示例

namespace jaosn
{
	//template<class T>
	//class vector
	//{};
	
	template<class T>
	class stack : public std::vector<T>
	{
	public:
		void push(const T& x)
		{
			vector<T>::push_back(x);	//指定类域
		}
		void pop()
		{
			vector<T>::pop_back();
		}
		const T& top()
		{
			return vector<T>::back();
		}
		bool empty()
		{
			return vector<T>::empty();
		}
	};
}
int main()
{
	jason::stack<int> st;
	st.push(1);
	st.push(2);
	st.push(3);
	while (!st.empty())
	{
		cout << st.top() << " ";
         st.pop();
	}
	return 0;
}

2. 基类和派生类间的转换

  • public继承的派生类对象 可以赋值给 基类的指针 / 基类的引用。这个操作称为切片或者切割。寓意把派生类中基类那部分切出来，基类指针或引用指向的是派生类中切出来的基类那部分。
  • 基类对象不能赋值给派生类对象，因为派生类对象有基类对象没有的成员。
  • 基类的指针或者引⽤可以通过强制类型转换赋值给派⽣类的指针或者引用。但是必须是基类的指针指向派⽣类对象时才是安全的。这⾥基类如果是多态类型，可以使⽤RTTI(Run-Time TypeInformation) 的 dynamic_cast来进行识别后进行安全转换。

在这里插入图片描述

代码示例

class Person
{
protected :
	string _name; // 姓名
	string _sex; // 性别
	int _age; // 年龄
};
class Student : public Person
{
public :
	int _No ; // 学号
};
int main()
{
	Student sobj ;
	// 1.派生类对象可以赋值给基类的指针/引⽤
	Person* pp = &sobj;
	Person& rp = sobj;
	// 派生类对象也可以通过调用基类的拷贝构造赋值给基类的对象——后⾯会讲解
	Person pobj = sobj;
	//2.基类对象不能赋值给派⽣类对象，这⾥会编译报错
	//sobj = pobj;
	return 0;
}

3. 继承中的作用域

3.1 隐藏规则

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

代码示例

// Student的_num和Person的_num构成隐藏关系
class Person
{
protected :
	string _name = "jason"; // 姓名
	int _num = 111; // ⾝份证号
};

class Student : public Person
{
public:
	void Print()
	{
		cout<<" 姓名:"<<_name<< endl;
		cout<<" ⾝份证号:"<<Person::_num<< endl;
		cout<<" 学号:"<<_num<<endl;
	}
protected:
	int _num = 999; // 学号
};

int main()
{
	Student s1;
	s1.Print();//结果为jason 111 999 
	return 0;
};

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

4.1 常见默认成员函数

  1. 派生类的构造函数必须调⽤基类的构造函数初始化基类的那⼀部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显式调用。
  2. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
  3. 派生类的operator=必须要调⽤基类的operator=完成对基类的赋值。需要注意的是派生类的operator=隐藏了基类的operator=，所以显式调⽤基类的operator=，需要指定基类作⽤域。
  4. 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。
  5. 由2、3、4可知，派生类的拷贝构造，赋值重载，析构函数默认生成的就够用了，如果有需要显式释放的资源，才需要自己去实现。
  6. 默认生成的构造函数的行为：1.内置类型—>不确定 2.自定义类型 —>调用默认构造 3.继承的父类成员（可以看做一个整体，当做自定义类型）—>调用父类的默认构造。
  7. 派⽣类对象初始化先调用基类构造再调派⽣类构造；派生类对象析构清理先调用派生类析构再调基类的析构。

在这里插入图片描述

8.因为多态中⼀些场景析构函数需要构成重写，重写的条件之⼀是函数名相同。那么编译器会对析构函数名进⾏特殊处理，处理成destructor()，所以基类析构函数不加virtual的情况下，派生类析构函数和基类析构函数构成隐藏关系（均为destructor()）。

代码示例

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 ; //学号
};

int main()
{
	Student s1 ("jason", 18);
	Student s2 (s1);
	Student s3 ("django", 17);
	s1 = s3 ;
	return 0;
}

4.2 实现一个不能被继承的类

⽅法1：将基类的构造函数私有。因为派⽣类的构成必须调用基类的构造函数，但是基类的构成函数私有化以后，派生类看不见就不能调用了，那么派生类就无法实例化出对象。

⽅法2：C++11新增了⼀个final关键字，final修改基类，派生类就不能继承了。

代码示例

// C++11的⽅法
class Base final
{
public:
	void func5() { cout << "Base::func5" << endl; }
protected:
	int a = 1;
private:
	// C++98的⽅法
	/*Base()
	{}*/
};

class Derive :public Base
{
	void func4() { cout << "Derive::func4" << endl; }
protected:
	int b = 2;
};
int main()
{
	Base b;
	Derive d;
	return 0;
}

5. 继承与友元

友元关系不能继承，也就是说基类友元不能访问派生类私有和保护的成员。

代码示例

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

6. 继承与静态成员

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

代码示例

class Person
{
public:
	string _name;
	static int _count;
};
int Person::_count = 0;
class Student : public Person
{
protected:
	int _stuNum;
};
int main()
{
	Person p;
	Student s;
	// 这⾥的运⾏结果可以看到⾮静态成员_name的地址是不⼀样的
	// 说明派⽣类继承下来了，⽗派⽣类对象各有⼀份
	cout << &p._name << endl;
	cout << &s._name << endl;
	// 这⾥的运⾏结果可以看到静态成员_count的地址是⼀样的
	// 说明派⽣类和基类共⽤同⼀份静态成员
	cout << &p._count << endl;
	cout << &s._count << endl;
	// 公有的情况下，⽗派⽣类指定类域都可以访问静态成员
	cout << Person::_count << endl;
	cout << Student::_count << endl;
	return 0;
}

7. 多继承及其菱形继承的问题

7.1 继承模型

单继承：⼀个派生类只有⼀个直接基类时称这个继承关系为单继承。

多继承：⼀个派⽣类有两个或以上直接基类时称这个继承关系为多继承，多继承对象在内存中的模型是，先继承的基类在前面，后继承的基类在后面，派生类成员在放到最后面。

菱形继承：菱形继承是多继承的⼀种特殊情况。菱形继承的问题，从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题，在Assistant的对象中Person成员会有两份。支持多继承就一定会有菱形继承。在实践中不建议设计出菱形继承。

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

代码示例

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()
{
	// 编译报错：error C2385: 对“_name”的访问不明确
	Assistant a;
	a._name = "peter";
	// 需要显⽰指定访问哪个基类的成员可以解决⼆义性问题，但是数据冗余问题	⽆法解决
	a.Student::_name = "xxx";
	a.Teacher::_name = "yyy";
	return 0;
}

7.2 虚继承virtual

  1. 针对菱形继承问题，子类需要在继承公共基类（具有二义性的类）时加入virtual关键字来解决，这个时候冗余的部分就被分解成一份放到了派生类的成员的后面（内存空间的角度）。
  2. 哪两个类在继承公共基类时产生二义性就加virtual。也就是说如果是菱形继承，就一定需要两个派生类加virtual才能避免二义性。
  3. 在菱形继承没有成型之前不要加virtual。

代码示例

class Person
{
public:
	string _name; // 姓名
	/*int _tel;
	int _age;
	string _gender;
	string _address;*/
	// ...
};

// 使⽤虚继承Person类
class Student : virtual public Person
{
protected:
	int _num; //学号
};

// 使⽤虚继承Person类
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;
}

8. 继承和组合

  • 继承关系 格式：class stack : public list {};
  • 组合关系 格式class stack{list _lt;};，就是在子类中用父类实例化对象。
  • 继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用(white-box reuse)。术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对派生类可见 。继承⼀定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。
  • 对象组合是类继承之外的另⼀种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接⼝。这种复用风格被称为黑箱复用(black-box reuse)，因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。 组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装。

代码示例

// Tire(轮胎)和Car(⻋)更符合组合的关系
class Tire {
protected:
	string _brand = "Michelin"; // 品牌
	size_t _size = 17; // 尺⼨
};

class Car {
protected:
	string _colour = "⽩⾊"; // 颜⾊
	string _num = "陕ABIT00"; // ⻋牌号
	Tire _t1; // 轮胎
	Tire _t2; // 轮胎
	Tire _t3; // 轮胎
	Tire _t4; // 轮胎
};

class BMW : public Car {
public:
	void Drive() { cout << "好开-操控" << endl; }
};

// Car和BMW/Benz更符合继承的关系
class Benz : public Car {
public:
	void Drive() { cout << "好坐-舒适" << endl; }
};

template<class T>
class vector
{};

// stack和vector的关系，既符合继承，也符合组合
template<class T>
class stack : public vector<T>
{};

template<class T>
class stack
{
public:
	vector<T> _v;
};
DjangoJason
关注
C++继承
Wzs040810的博客
02-03 1711
C++继承
C++继承详解
lim6ere的博客
03-29 1309
在本篇文章中我们将会学到有关继承方面的知识，其中C++中三大特性分别为：封装，继承多态。由此可见继承在学习中的重要性，接下来我们来一起看一下有关继承方面的知识吧！！！！😘 😚😘 😚😘 😚以上就是今天要讲的内容，本文仅仅详细介绍了C++继承的相关知识。希望对大家的学习有所帮助，仅供参考 如有错误请大佬指点我会尽快去改正 欢迎大家来评论~~ 😘 😘 😘。
C++ 继承详解
热门推荐
TABE_的博客
02-21 1万+
C++ 继承继承语法继承方式改变访问权限名字遮蔽继承时的对象模型无变量遮蔽有变量遮蔽 继承语法 继承的一般语法为： class 派生类名:［继承方式］ 基类名{ 派生类新增加的成员 }; 继承方式 继承方式包括 public（公有的）、private（私有的）和 protected（受保护的），此项是可选的，如果不写，那么默认为 private。不同的继承方式会影响基类成员在派生类中的访问权限。 （1）public继承方式 基类中所有 public 成员在派生类中为 public 属性； 基类中
C++继承的使用
JayceSun的博客
04-17 2033
定义 继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特 性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构， 体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。 ...
C++继承（带你一篇文章搞定C++的继承）
2301_80344616的博客
10-23 4717
我们前面讲了模板进阶的全部内容，今天我们要进入C++里面更深层的内容了，今天我们来讲解C++的继承继承的概念继承机制是面向对象程序设计使代码可以复用的最重要的手段，它允许我们在保持原有类特性的基础上进行扩展，增加方法(成员函数)和属性(成员变量)，以前我们接触的函数层次的复用，继承是类设计层次的复用。什么是复用呢？
C++继承之private继承
flysnow010的博客
04-10 1650
通过继承机制，可以利用已有的对象类型来定义新对象类型。所定义的新对象类型不仅仅拥有新定义的成员，而且还同时拥有旧的成员。我们称已存在的用来派生新类的类为基类，又称为父类。由已存在的类派生出的新类称为派生类，又称为子类。 private继承 派生类中父类public成员变成private成员。
C++继承[万字详解]
weixin_47257473的博客
03-16 4304
本文非常详细介绍了C++中的继承，包括继承的定义，介绍，方式。以及继承后派生类构造函数和析构函数的调用顺序，继承中的切片等问题，继承后静态成员，友元关系的变化，以及多继承中的菱形继承和菱形虚拟继承，对继承的一些总结。继承和组合的介绍以及关系.
C++ 继承详解及实例代码
09-01
C++继承是面向对象编程中的一个核心概念，它允许创建一个新的类（子类或派生类）基于已存在的类（基类或父类）。通过继承，子类不仅可以获得基类的所有成员（包括数据成员和成员函数），还可以添加新的功能或者重写...
c++重点知识总结
Uk110的博客
06-06 879
1.基类private成员在派生类中无论以什么方式继承都是不可见的。这里的。
极限复习c++
2302_76213070的博客
06-05 2223
快速过一遍必背代码（类、多态、模板）和简答题答案，强化肌肉记忆！祝考试顺利，代码全 AC！
C/C++ 面试复习笔记（4）
apolloyhl的博客
06-06 923
内存颠簸是指系统在频繁地进行内存页的换入换出操作，导致大量的磁盘 I/O，系统性能急剧下降的现象。当系统的物理内存不足，而进程对内存的需求又不断变化时，就容易出现内存颠簸。例如，一个进程频繁地访问不同的内存页，而这些页在内存中频繁地被换出和换入。在 Linux 系统中，可以通过以下方法避免或解决内存颠簸问题：增加物理内存：如果物理内存不足是导致内存颠簸的主要原因，增加内存条可以直接提 高系统的可用内存，减少页交换操作。
加法c++
D_31415926的博客
06-06 386
给定 a 和 b 分别作为被加数和加数，而且限定 a 是 4 位数字，b 是 3 位数字，都是正整数。请你模拟以上加法过程进行输出。如果最后 a+b 的结果是 5 位数，为了保证对齐，需要在被加数和加数前面加空格。只需判断a+b的位数（注：四位数+三位数只可能是四位数或五位数，因为1000+100=1100，9999+999=10998），当a+b为四位数或五位数时输出特定的格式即可。输入两个正整数 a 和 b。
【题解】[UTPC2024] C.Card Deck
最新发布
scy923的博客
06-07 577
由于放入袋中后会进行补位，也就是说我们并不关心补进来的是哪一张真正的原始牌，当进行第。轮之后所有可能的袋子里牌所组成的集合的大小之和。考虑进行转化，只考虑前。，表示这张牌永远不会被放入袋子中，否则表示这张牌会在第。因此可以对每一张牌单独计算贡献。原题的模型是每一步可以选择顶部。，则这张牌出现在集合里的次数为。的牌都已经放入袋中，总共有。张牌，每张牌都有一个属性。张牌等价，所以最后的答案为。(可以为空）放在袋中，求。轮后袋子里的数，最后求。，下证明两个模型等价。
如何在c/c++中定义和使用宏
wydaicls的博客
06-07 386
本文介绍了C/C++中的宏定义和条件编译机制。宏定义分为对象式宏（如#define PI 3.1415926）和函数式宏（如#define MAX(a,b)），在预处理阶段进行文本替换，使用时需注意括号和多行定义的处理。条件编译通过#ifdef、#ifndef、#if等指令实现，其中#ifdef检查宏是否定义，#if使用表达式判断，并可用#elif和#else进行多分支控制。#undef可取消宏定义，#pragma once能防止头文件重复包含。这些预处理指令为代码提供了编译时的灵活控制能力。
使用 C/C++ 和 OpenCV 提取图像的感兴趣区域 (ROI)
m0_54069809的博客
06-07 848
本文介绍了使用C++和OpenCV库从图像中提取感兴趣区域(ROI)的方法。主要步骤包括：通过cv::imread()加载图像，用cv::Rect定义矩形ROI区域，利用cv::Mat的()运算符提取ROI，最后用cv::imshow()显示结果。文章提供了完整示例代码，并特别指出默认提取的是视图而非独立拷贝，若需独立操作可使用clone()或copyTo()方法创建深拷贝。该技术是计算机视觉中目标检测和图像分割等任务的基础。
C++继承详解与示例
"C++继承介绍，讲解了C++中的继承概念，包括public继承以及virtual、non-virtual和pure virtual成员函数的区别。通过示例代码展示了如何使用继承，并且验证了基类指针可以调用派生类对象的方法，但反之不行。" 在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值