当前位置： 首页 > ops >正文

C++继承语法讲解

ops 2025/9/4 2:16:32

1. 继承的概念及定义

1.1 概念

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

下面我们可以看到没有继承之前我们设计了两个类Student和Teacher，Student和Teacher都有姓名/地址/电话/年龄等成员变量，都有identity身份认证的成员函数，设计到两个类里面就是冗余的。当然他们也有一些不同的成员变量和函数，比如老师独有的成员变量是职称，学生的独有成员变量是学号；学生的独有函数是学习，老师的独有函数是授课。

#include<string>
#include<iostream>using namespace std;class Student
{
public:void identity(){cout << "void identity()" << endl;}void study(){cout << "void study()" << endl;}protected:string _name = "张三";string _address;string _tel;int _age = 18;int _id;
};class Teacher
{
public:void identity(){cout << "void identity()" << endl;}void teaching(){cout << "void teaching()" << endl;}protected:string _name = "李四";string _address;string _tel;int _age = 38;string _title;
};int main()
{return 0;
}

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

#include<iostream>using namespace std;class Person
{
public:void identity(){cout << "void identity()" << endl;}protected:string _name;string _address;string _tel;int _age;
};class Student : public Person
{
public:void study(){cout << "void study()" << endl;}protected:int _id;
};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 定义

1.2.1 定义格式

下面我们看到Person是基类，也称作父类。Student和Teacher是派生类，也成为子类。（因为翻译的原因，所以也叫基类/派生类，也叫父类/子类）。

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

类成员/继承方式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，不过最好显示的写出继承方式。

5. 实际运用中一般使用的都是public继承，几乎很少使用protected和private继承。

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

1. public继承的派生类对象可以赋值给基类的指针/基类的引用。这里有个形象的说法叫切片或者切割。寓意把派生类中基类的那部分切出来，基类指针或引用指向的是派生类切出来的基类那部分。

2. 基类对象不能赋值给派生类对象。

#include<iostream>using namespace std;class Person
{
protected:string _name;string _sex;int _age;
};class Student : public Person
{
public:int _No;
};int main()
{Student s;// 1. 派⽣类对象可以赋值给基类的指针/引⽤Person* ps = &s;Person& rs = s;// 2. 基类对象不能赋值给派⽣类对象，这⾥会编译报错Person p;//s = p;return 0;
}

3. 继承中的作用域

3.1 隐藏规则：

1. 在继承体系中基类和派生类都有独立的作用域。

2. 派生类和基类中有同名成员，派生类成员将屏蔽基类对同名成员的直接访问，这种情况叫隐藏。（在派生类成员函数中，可以使用 基类::基类成员 显示访问）。

3. 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。

4. 注意在实际中在继承体系里面最好不要定义同名的成员。

#include<iostream>using namespace std;class Person
{
protected:string _name = "张三";int _id = 123;// 身份证号
};class Student : public Person
{
public:void Print(){cout << "姓名：" << _name << endl;cout << "身份证号：" << Person::_id << endl;cout << "学号：" << _id << endl;}protected:int _id = 999;// 学号
};int main()
{Student s;s.Print();return 0;
}

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

4.1 常见的默认成员函数

默认成员函数，默认的意思是指我们不写，编译器会自动生成一个，那么在派生类中，这几个成员函数是如何生成的呢？
1. 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表显示调用。

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

3. 派生类的operator=必须要调用基类的operator=完成基类的复制。需要注意的是派生类的operator=隐藏了基类operator=，所以显示调用基类的operator=，需要指定基类作用域。

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

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

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

#include<string>
#include<iostream>using namespace std;class Person
{
public:Person(const string& name = "张三"):_name(name){cout << "Person(const string& name)" << 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 string& name, int id = 123):Person(name),_id(id){cout << "Student(const string& name, int id = 123)" << endl;}Student(const Student& s):Person(s),_id(s._id){cout << "Student(const Student& s)" << endl;}Student& operator=(const Student& s){cout << "Student& operator=(const Student& s)" << endl;if (this != &s){Person::operator=(s);_id = s._id;}return *this;}~Student(){cout << "~Student()" << endl;}protected:int _id;
};int main()
{Student s1("lisi", 18);Student s2(s1);Student s3("wangwu", 20);s1 = s3;return 0;
}

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

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

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

#include<iostream>using namespace std;// 方法2
class Base //final
{
public:void Func5(){cout << "Base::Func5" << endl;}
protected:int _a = 1;
private:// 方法1//Base()//{ }
};class Derive : public Base
{
public:void Func4(){cout << "Derive::Func4" << endl;}
protected:int _b = 2;
};int main()
{Base b;Derive d;return 0;
}

5. 继承与友元

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

#include<iostream>using namespace std;class Student;class Person
{
public: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;
}int main()
{Person p;Student s;// 编译报错：error C2248: “Student::_stuNum”: ⽆法访问 protected 成员// 解决⽅案：Display也变成Student 的友元即可Display(p, s);return 0;
}

6. 继承与静态成员

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

#include<iostream>using namespace std;class Person
{
public:string _name;static int _count;
};int Person::_count = 0;class Student : public Person
{
protected:int _id;
};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成员会有两份。

#include<iostream>using namespace std;class Person
{
public:string _name;
};class Student : public Person
{
protected:int _id; // 学号
};class Teacher : public Person
{
protected:int _title; // 职称
};class Assistant : public Student, public Teacher
{
protected:string _major_course; // 主修课程
};int main()
{Assistant a;// 编译报错：error C2385: 对“_name”的访问不明确//a._name = "张三";// 需要显⽰指定访问哪个基类的成员可以解决⼆义性问题，但是数据冗余问题⽆法解决a.Student::_name = "张三";a.Teacher::_name = "李四";return 0;
}

7.2 虚继承

很多人说C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承。用虚继承就可以解决上面的问题。

#include<iostream>using namespace std;class Person
{
public:string _name;
};class Student : virtual public Person
{
protected:int _id; // 学号
};class Teacher : virtual public Person
{
protected:int _title; // 职称
};class Assistant : public Student, public Teacher
{
protected:string _major_course; // 主修课程
};int main()
{Assistant a;a._name = "张三";return 0;
}

http://www.xdnf.cn/news/4718.html

相关文章：

  • 2025最新：3分钟使用Docker快速部署Redis集群
  • 为什么 MySQL 用 B+ 树作为数据的索引，以及在 InnoDB 中数据库如何通过 B+ 树索引来存储数据以及查找数据
  • base64与图片的转换和预览(高阶玩法)
  • 【Ubuntu系统镜像文件下载（官网）】
  • AI赋能高频PCB信号完整性优化
  • 正态分布和幂律分布
  • 存储器：DDR和HBM的区别
  • css样式基础
  • Python中，正则表达式，
  • 观察者GIS知识星球资源汇总-2025V1
  • 当数据爆炸遇上SQL Server：优化策略全链路解析
  • 深度解析语义分割评估指标：从基础到创新实践
  • TLS（传输层安全协议）
  • 66、微服务保姆教程（九）微服务的高可用性
  • 代码随想录第37天：动态规划10（公共子序列问题）
  • css3伸缩盒模型第三章(伸缩相关)
  • obj = null； 赋值null之前没有其他引用指向obj对象，那么，当obj=null时，会被垃圾回收机制立即回收吗？
  • 湖北理元理律师事务所：债务优化中的“生活保障”方法论
  • PCIe控制器介绍（二）
  • 47. 全排列 II
  • C++类继承学习笔记
  • 【软件推荐——ScreenToGif】
  • flutter 资料收集
  • Unity基础学习（九）基本组件Transform
  • 土壤电导率传感器测定土壤溶液中的可溶盐离子 智慧农业指导作用
  • 如何使用原点回归方式35进行回原
  • RHEL8搭建FOU隧道
  • Mybatis解决以某个字段存在，批量更新，不存在批量插入（高效）（一）
  • 【QT】深入理解 Qt 中的对象树：机制、用途与最佳实践
  • 第十六届蓝桥杯大赛软件赛C/C++大学B组部分题解