【C++修炼之路】C++继承的探索

🏝️专栏： 【C++修炼之路】

🌅主页： f狐o狸x

"莫等闲，白了少年头，空悲切"

---

目录

一、继承的概念及定义

[1.1 继承的概念](#1.1 继承的概念)

[1.2 继承定义](#1.2 继承定义)

[1.3 继承类模版](#1.3 继承类模版)

二、基类和派生类间的转换

三、继承中的作用域

四、派生类的默认成员函数

[4.1 常见的默认成员函数](#4.1 常见的默认成员函数)

[4.2 实现一个不能被继承的类](#4.2 实现一个不能被继承的类)

五、继承与静态成员

六、继承与组合

七、总结

---

之前断更了很久很久，是我去考研啦，现在让我们继续开始新的生活吧！文章主要记录我在学习过程中的一些心得体会，如果有错误的地方请及时联系我改正，也欢迎各位小伙伴来和我一起讨论学习！

C++中三大特性：继承、封装和多态。今天，我们来学习继承的相关知识。

在正式学习继承之前，我们先思考一个问题：如果没有继承，代码会变成什么样？假设我们要描述学生和老师两类对象，他们都有姓名、年龄等公共属性，也有吃饭、睡觉等公共行为。如果分别定义两个类，这些公共成员就不得不重复书写，代码冗余不说，后期一旦需要修改公共属性，还得同时改动多处，极易出错。

继承正是为了解决这类问题而生的。它允许我们基于已有的类创建新类，新类可以复用父类的成员，同时还能扩展属于自己的新成员。这样一来，公共部分只需在父类中维护一次，子类自动拥有，代码更加简洁，层次也更加清晰。接下来，我们就从继承的概念开始，一步步深入理解 C++ 中的继承机制。

一、继承的概念及定义

1.1 继承的概念

继承机制是面向对象程序设计使代码可以复用的重要手段，它允许我们在保持原有类特性的基础上进行扩展，增加方法和属性，这样产生的新的类，称为派生类（子类）。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。

下面我将用没有继承设计两个类Student和Teacher：

class Student
{
public:
	// 身份认证
	void identity()
	{

	}
	// 学习
	void study()
	{

	}
protected:
	string _name;   // 姓名
	string _address;// 地址
	string _tel;    // 电话
	int _age;       // 年龄

	int _stuid;     // 学号 
};

class Teacher
{
public:
	// 身份认证
	void identity()
	{

	}
	// 上课
	void teaching()
	{

	}
protected:
	string _name;   // 姓名
	string _address;// 地址
	string _tel;    // 电话
	int _age;       // 年龄

	int _title;     // 职称
};

在这两个类里面，Student和Teacher都有姓名，地址，电话，年龄这些成员变量，都有identity身份认证的成员函数，这些设计就是冗余的。

下⾯我们公共的成员都放到Person类中，Student和teacher都继承Person，就可以复⽤这些成员，就 不需要重复定义了，省去了很多⿇烦。

class Person
{
public:
    // 身份认证
	void identity()
	{
		cout << "void identity()" << endl;
	}
protected:
	string _name;   // 姓名
	int _age = 18;  // 年龄
	string _address;// 地址
	string _tel;    // 电话
};

class Student : public Person
{
public:
    // 学习
	void study()
	{
		cout << "void study()" << endl;
	}
protected:
	int _stuid;// 学号

};

class Teacher : public Person
{
public:
    // 授课
	void teaching()
	{
		cout << "void teaching()" << endl;
	}
protected:
	string title;// 职称
};

int main()
{
	Student s;
	Teacher t;
	s.identity();
	t.identity();
	return 0;
}

1.2 继承定义

上面的例子中，Person是基类（父类），Student和Teacher是派生类（子类）

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

|--------------------|-----------------|-----------------|---------------|
| 类成员/继承方式 | public继承 | protected继承 | private继承 |
| 基类的public成员 | 派生类的public成员 | 派生类的protected成员 | 派生类的private成员 |
| 基类的protected成员 | 派生类的protected成员 | 派生类的protected成员 | 派生类的private成员 |
| 基类的private成员 | 在派生类中不可见 | 在派生类中不可见 | 在派生类中不可见 |

1. 基类private成员在派⽣类中⽆论以什么⽅式继承都是不可⻅的。这⾥的不可⻅是指基类的私有成员 还是被继承到了派⽣类对象中，但是语法上限制派⽣类对象不管在类⾥⾯还是类外⾯都不能去访问 它。
2. 基类private成员在派⽣类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派⽣类 中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。
3. 实际上⾯的表格我们进⾏⼀下总结会发现，基类的私有成员在派⽣类都是不可⻅。基类的其他成员 在派⽣类的访问⽅式==Min(成员在基类的访问限定符，继承⽅式)，public >protected> private。
4. 使⽤关键字class时默认的继承⽅式是private，使⽤struct时默认的继承⽅式是public，不过最好显 ⽰的写出继承⽅式。

实例演⽰三种继承关系下基类成员的各类型成员访问关系的变化：

class Person
{
public:
	void Print()
	{
		cout << _name << endl;
	}
protected:
	string _name; // 姓名
private:
	int _age;// 年龄
};

//class Student : protected Person
//class Student : private Person
class Student : public Person
{
protected:
	int _stunum; // 学号
}

1.3 继承类模版

namespace fox
{
	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()
{
	fox::stack<int> st;
	st.push(1);
	st.push(2);
	st.push(3);
	st.push(4);

	while (!st.empty())
	{
		cout << st.top() << endl;
		st.pop();
	}

	return 0;
}

二、基类和派生类间的转换

• public继承的派⽣类对象可以赋值给基类的指针/基类的引⽤。这⾥有个形象的说法叫切⽚或者切割。寓意把派⽣类中基类那部分切出来，基类指针或引⽤指向的是派⽣类中切出来的基类那部分。
• 基类对象不能赋值给派⽣类对象。
• 基类的指针或者引⽤可以通过强制类型转换赋值给派⽣类的指针或者引⽤。但是必须是基类的指针 是指向派⽣类对象时才是安全的。

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;

	//基类对象不能直接赋值给派生类对象，编译器会报错
	//sobj = pobj;

	return 0;
}

三、继承中的作用域

隐藏规则：

1. 在继承体系中基类和派⽣类都有独⽴的作⽤域。
2. 派⽣类和基类中有同名成员，派⽣类成员将屏蔽基类对同名成员的直接访问，这种情况叫隐藏。
3. 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏
4. 注意在实际中在继承体系⾥⾯最好不要定义同名的成员。

class Person
{
protected:
	string _name = "狐狸";
	int _num = 111;
};

class Student : public Person
{
public:
	void print()
	{
		cout << "姓名：" << _name << endl;
		cout << "身份证号：" << Person::_num << endl;
		cout << "学号：" << _num << endl;
	} 
protected:
	int _num = 222;
};

int main()
{
	Student s1;
	s1.print();


	return 0;
}

四、派生类的默认成员函数

4.1 常见的默认成员函数

6个默认成员函数数，默认的意思就是指我们不写，编译器会变我们⾃动⽣成⼀个，那么在派⽣类中，这⼏个成员函数是如何⽣成的呢

1. 派⽣类的构造函数必须调⽤基类的构造函数初始化基类的那⼀部分成员。如果基类没有默认的构造函数，则必须在派⽣类构造函数的初始化列表阶段显⽰调⽤。
2. 派⽣类的拷⻉构造函数必须调⽤基类的拷⻉构造完成基类的拷⻉初始化。
3. 派⽣类的operator=必须要调⽤基类的operator=完成基类的复制。需要注意的是派⽣类的operator=隐藏了基类的operator=，所以显⽰调⽤基类的operator=，需要指定基类作⽤域
4. 派⽣类的析构函数会在被调⽤完成后⾃动调⽤基类的析构函数清理基类成员。因为这样才能保证派⽣类对象先清理派⽣类成员再清理基类成员的顺序。
5. 派⽣类对象初始化先调⽤基类构造再调派⽣类构造。
6. 派⽣类对象析构清理先调⽤派⽣类析构再调基类的析构。

class Person
{
public:
	Person(const char* name = "fox")
		:_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("jack", 18);
	Student s2(s1);
	Student s3("rose", 17);
	s1 = s3;

	return 0;
}

运行结果：

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

五、继承与静态成员

基类定义了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;
}

六、继承与组合

• public继承是⼀种is-a的关系。也就是说每个派⽣类对象都是⼀个基类对象。
• 组合是⼀种has-a的关系。假设B组合了A，每个B对象中都有⼀个A对象。
• 继承允许你根据基类的实现来定义派⽣类的实现。这种通过⽣成派⽣类的复⽤通常被称为⽩箱复⽤(white-box reuse)。术语"⽩箱"是相对可视性⽽⾔：在继承⽅式中，基类的内部细节对派⽣类可⻅。继承⼀定程度破坏了基类的封装，基类的改变，对派⽣类有很⼤的影响。派⽣类和基类间的依赖关系很强，耦合度⾼。
• 对象组合是类继承之外的另⼀种复⽤选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接⼝。这种复⽤⻛格被称为⿊箱复⽤(black-boxreuse)，因为对象的内部细节是不可⻅的。对象只以"⿊箱"的形式出现。组合类之间没有很强的依赖关系，耦合度低。优先使⽤对象组合有助于你保持每个类被封装。
• 优先使⽤组合，⽽不是继承。实际尽量多去⽤组合，组合的耦合度低，代码维护性好。不过也不太那么绝对，类之间的关系就适合继承(is-a)那就⽤继承，另外要实现多态，也必须要继承。类之间的关系既适合⽤继承(is-a)也适合组合(has-a)，就⽤组合

七、总结

本文系统梳理了 C++ 继承机制的核心知识点。我们从继承的概念出发，理解了它如何通过复用父类成员来解决代码冗余问题；接着学习了继承定义中基类成员访问方式的变化规则，以及继承类模板的写法；随后掌握了基类和派生类之间的转换规则、继承中的作用域与隐藏规则，并深入分析了派生类默认成员函数的调用机制。

在进阶部分，我们探讨了继承与静态成员的关系，明确了整个继承体系中静态成员只有一份实例；最后对比了继承与组合两种复用方式，理解了 is-a 与 has-a 关系的区别，以及优先使用组合的设计原则。

继承是 C++ 面向对象编程的三大特性之一，它与封装、多态共同构成了面向对象设计的基石。理解继承不仅有助于写出更简洁、可维护的代码，也是后续学习多态、虚函数等高级特性的重要前提。希望本文能帮助大家打好基础，在后续的学习中继续深入探索 C++ 的魅力。

---

学习是一件不容易的事情，希望我们可以坚持下去！！！加油各位！