揭开C++ 继承 的神秘面纱：深度剖析 类 的“血脉”传承
在C++的面向对象编程中，继承（Inheritance）是实现代码复用和层次结构的重要特性。通过继承，新的类（派生类）可以从现有的类（基类）中继承属性和行为，从而减少重复代码，并将共同的特性封装在更高层次的基类中。继承不仅使代码更具组织性，还支持多态性和接口共享，使派生类能够在特定场景下提供独特的实现，而不改变原有接口。本文将带你深入探索C++继承的机制、类型以及继承中的关键概念，让你更灵活地构建高效、可扩展的面向对象程序。
1. 继承的概念和定义
1.1 继承的概念
在面向对象编程（OOP）中，继承是一种关键的机制，用于创建层次化的类结构，使代码复用更为方便。继承允许我们定义一个新类（称为派生类或子类），从已有的类（称为基类或父类）继承其属性和行为，并在其基础上进行扩展，增加方法和属性。
继承的核心概念在于“是一种”（is-a）关系——也就是说，派生类是基类的一个具体化或特化版本。
继承的目的是为了复用代码和组织类结构，主要包含以下几点：
（1）代码复用：派生类自动拥有基类的所有属性和方法，因此可以避免重复代码的编写。
（2）层次化结构：通过继承，不同的类可以构成一个层次结构，从而更清晰地表达不同对象之间的关系。比如，在“动物”基类的基础上，可以定义“猫”和“狗”等具体的派生类。
class Student
{
public:
// 进⼊校园/图书馆/实验室刷⼆维码等⾝份认证
void identity()
{
// ...
}
// 学习
void study()
{
// ...
}
protected:
string _name = "peter"; // 姓名
string _address; // 地址
string _tel; // 电话
int _age = 18; // 年龄
int _stuid; // 学号
};
class Teacher
{
public:
// 进⼊校园/图书馆/实验室刷⼆维码等⾝份认证
void identity()
{
// ...
}
// 授课
void teaching()
{
//...
}
protected:
string _name = "张三"; // 姓名
int _age = 18; // 年龄
string _address; // 地址
string _tel; // 电话
string _title; // 职称
};
int main()
{
return 0;
}class Person
{
public:
// 进⼊校园/图书馆/实验室刷⼆维码等⾝份认证
void identity()
{
cout << "void identity()" << _name << endl;
}
protected:
string _name = "张三"; // 姓名
string _address; // 地址
string _tel; // 电话
int _age = 18; // 年龄
};
class Student : public Person
{
public:
// 学习
void study()
{
// ...
}
protected:
int _stuid; // 学号
};
class Teacher : public Person
{
public:
// 授课
void teaching()
{
//...
}
protected:
string title; // 职称
};
int main()
{
Student s;
Teacher t;
s.identity();
t.identity();
return 0;
}1.2 继承的定义
定义一个派生类（子类）时，可以使用基类（父类）作为其基础，通过不同的访问控制（如 public、protected 或 private）来控制继承的权限。这种继承机制赋予了派生类访问基类的成员，同时也允许派生类扩展或重写基类的功能。
1.2.1 定义的格式
继承方式有public继承、protect继承、private继承三种
访问限定符有public访问、protect访问、private访问三种
1.2.2 继承基类成员访问方式
不同的访问控制符对继承有不同的影响：
1. 基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员虽然被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。
2. 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。
3. 在实际运用中⼀般使用都是public继承，几乎很少使用protetced/private继承，也不提倡使用 protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。
4. public 继承：基类的 `public` 和 `protected` 成员在派生类中保持相同的访问级别。也就是说，基类的 `public` 成员在派生类中仍然是 `public` 的，`protected` 成员仍然是 `protected` 的。
5. protected 继承：基类的 `public` 和 `protected` 成员在派生类中都变成 `protected` 成员。这种继承方式限制了派生类的成员在类外的访问权限，通常用于内部实现的封装。
6. private 继承：基类的 `public` 和 `protected` 成员在派生类中都变成 `private` 成员，这意味着它们只能在派生类的内部访问，不对类外部公开。这种继承方式在不希望外界访问基类成员时使用，但依然可以复用基类的实现。
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 bit
{
//template<class T>
//class vector
//{};
// stack和vector的关系，既符合is-a，也符合has-a
template<class T>
class stack : public std::vector<T>
{
public:
void push(const T& x)
{
// 基类是类模板时，需要指定⼀下类域，
// 否则编译报错:error C3861: “push_back”: 找不到标识符
// 因为stack<int>实例化时，也实例化vector<int>了
// 但是模版是按需实例化，push_back等成员函数未实例化，所以找不到
vector<T>::push_back(x);
//push_back(x);
}
void pop()
{
vector<T>::pop_back();
}
const T& top()
{
return vector<T>::back();
}
bool empty()
{
return vector<T>::empty();
}
};
}
int main()
{
bit::stack<int> st;
st.push(1);
st.push(2);
st.push(3);
while (!st.empty())
{
cout << st.top() << " ";
st.pop();
}
return 0;
}2.基类和派生类之间的转换
在 C++ 中，派生类和基类之间的转换是继承机制的一个重要部分。通过这种转换，我们可以灵活地在基类和派生类之间进行操作。主要的转换类型包括上行转换和下行转换。
2.1 上行转换（派生类转换为基类）
上行转换是指将派生类对象转换为基类对象。这种转换是隐式的，即不需要显示的类型转换符。上行转换的目的是通过基类的指针或引用来操作派生类对象，是实现多态的基础。
特点：
- 允许基类的指针或引用指向派生类的对象。
- 由于是隐式转换，因此非常简单和常见。
- 在上行转换时，只能通过基类的接口访问基类的成员，派生类独有的成员将不可访问。
也就是说public继承的派生类对象可以赋值给基类的指针 / 基类的引用。这⾥有个形象的说法叫切片或者切割。寓意把派生类中基类那部分切出来。
2.2 下行转换（基类转换为派生类）
下行转换是将基类指针或引用转换为派生类指针或引用。这种转换需要使用显式的类型转换操作符（如 `static_cast` 或 `dynamic_cast`），因为它可能是一个不安全的操作。
特点：
- 允许派生类的指针或引用访问基类指针所指向的派生类对象。
- 不安全：如果基类指针或引用指向的不是派生类对象，则会产生错误。
- `dynamic_cast` 可以在多态类型中进行安全检查，而 `static_cast` 不会做运行时检查。
也就是说基类对象不能赋值给派生类对象。基类的指针或者引用可以通过强制类型转换赋值给派⽣类的指针或者引用。但是必须是基类的指针是指向派生类对象时才是安全的。这里基类如果是多态类型，可以使用RTTI(Run-Time Type Information)的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;
//需要显示使用类型转换操作符
sobj = dynamic_cast<Student*> (sobj);
return 0;
}3. 继承中的作用域
3.1 隐藏规则
隐藏规则指的是派生类的成员（包括变量和函数）可能会隐藏同名的基类成员。这种隐藏会发生在函数重载、数据成员和静态成员的定义中。
1. 在继承体系中基类和派生类都有独立的作用域。
// Student的_num和Person的_num构成隐藏关系，可以看出这样代码虽然能跑，但是⾮常容易混淆
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 = 999; // 学号
};
int main()
{
Student s1;
s1.Print();
return 0;
};
4. 派生类的默认成员函数
在 C++ 中，派生类会自动继承基类的默认成员函数，但在继承关系下，这些成员函数的行为可能会有所变化。默认的意思就是指我们不写，编译器会变我们自动生成⼀个。C++ 中的默认成员函数包括：
1. 默认构造函数
2. 拷贝构造函数
3. 移动构造函数
4. 拷贝赋值运算符
5. 移动赋值运算符
6. 析构函数
4.1 4个常见的默认成员函数
class Person {
public:
int age;
string name;
// 带参数的构造函数(非默认构造)
Person(int a, string n)
: age(a)
, name(n)
{
cout << "调用基类构造" << endl;
}
};
class Student : public Person {
public:
int studentID;
// 派生类构造函数必须显式调用基类构造函数
Student(int a, string n, int id)
: Person(a, n)
, studentID(id)
{
cout << "调用派生类构造" << endl;
}
};
int main() {
Student s(20, "Alice", 12345);
// 输出：
// 调用基类构造
// 调用派生类构造
return 0;
}class Person {
public:
int age;
string name;
Person(int a, string n) : age(a), name(n) {}
// 拷贝构造函数
Person(const Person& p)
: age(p.age)
, name(p.name)
{
cout << "基类拷贝构造" << endl;
}
};
class Student : public Person {
public:
int studentID;
Student(int a, string n, int id) : Person(a, n), studentID(id) {}
// 派生类的拷贝构造函数
Student(const Student& s)
: Person(s)
, studentID(s.studentID)
{
cout << "派生类的拷贝构造" << endl;
}
};
int main() {
Student s1(20, "Alice", 12345);
Student s2 = s1; // 调用拷贝构造函数
// 输出：
// 基类拷贝构造
// 派生类拷贝构造
return 0;
}4. 派生类的operator=必须要 调用基类的operator= 完成基类的复制。需要注意的是派生类的 operator=隐藏了基类的operator=，所以显示调用基类的operator=，需要指定基类作用域。
class Person {
public:
int age;
string name;
Person(int a, string n) : age(a), name(n) {}
// 赋值运算符
Person& operator=(const Person& p)
{
age = p.age;
name = p.name;
cout << "基类重载=" << endl;
return *this;
}
};
class Student : public Person {
public:
int studentID;
Student(int a, string n, int id) : Person(a, n), studentID(id) {}
// 派生类的赋值运算符
Student& operator=(const Student& s)
{
if (this != &s)
{
Person::operator=(s); // 显式调用基类的 operator=
studentID = s.studentID;
cout << "派生类重载=" << endl;
}
return *this;
}
};
int main() {
Student s1(20, "Alice", 12345);
Student s2(21, "Bob", 67890);
s2 = s1; // 调用赋值运算符
// 输出：
// 基类重载=
// 派生类重载=
return 0;
}5. 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。
class Person {
public:
int age;
string name;
Person(int a, string n) : age(a), name(n) {
cout << "基类构造" << endl;
}
~Person() {
cout << "基类析构" << endl;
}
};
class Student : public Person {
public:
int studentID;
Student(int a, string n, int id) : Person(a, n), studentID(id) {
cout << "派生类构造" << endl;
}
~Student() {
cout << "派生类析构" << endl;
}
};
int main() {
Student s(20, "Alice", 12345);
// 输出：
//基类构造
//派生类构造
//派生类析构
//基类析构
return 0;
}7. 因为多态中⼀些场景析构函数需要构成重写，重写的条件之⼀是函数名相同那么编译器会对析构函数名进行特殊处理，处理成destructor()，所以基类析构函数不加virtual的情况下，派生类析构函数和基类析构函数构成隐藏关系。（这个会在后面的多态博客中详细讲解）
总结：
- 派生类会自动继承基类的默认成员函数，但在生成这些函数时会涉及基类的成员函数调用。
- 默认成员函数的生成和调用顺序由编译器控制，基类成员会在派生类成员之前被处理（构造时优先构造基类，析构时优先析构派生类）。
- 通过显式调用基类的默认成员函数，可以控制基类部分的初始化或赋值过程。
4.2 实现一个不能被继承的类
// C++11的⽅法
class Base final
{
public:
void func5() { cout << "Base::func5" << endl; }
protected:
int a = 1;
private:
};
//报错
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
{
//friend void Display(const Person& p, const Student& s);
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;
// 编译报错：error C2248: “Student::_stuNum”: ⽆法访问 protected 成员
// 解决⽅案：Display也变成Student 的友元即可
Display(p, s);
return 0;
}6. 继承与静态函数
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 继承模型
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;
// 编译报错：error C2385: 对“_name”的访问不明确
a._name = "peter";
// 需要显⽰指定访问哪个基类的成员可以解决⼆义性问题，但是数据冗余问题⽆法解决
a.Student::_name = "xxx";
a.Teacher::_name = "yyy";
return 0;
}7.2 虚继承
虚继承用于解决继承中菱形继承问题。
虚继承通过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. 继承和组合
// Tire(轮胎)和Car(⻋)更符合has-a的关系
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; // 轮胎
};
// Car和BMW/Benz更符合is-a的关系
class BMW : public Car
{
public:
void Drive() { cout << "好开-操控" << endl; }
};
class Benz : public Car
{
public:
void Drive() { cout << "好坐-舒适" << endl; }
};
// stack和vector的关系，既符合is-a，也符合has-a
template<class T>
class vector
{};
template<class T>
class stack : public vector<T>
{};
template<class T>
class stack
{
public:
vector<T> _v;
};
int main()
{
return 0;
}原文地址：https://blog.csdn.net/wangchen_0/article/details/143405594
免责声明：本站文章内容转载自网络资源，如侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！