首页 > 编程语言 >C++中的继承

C++中的继承

时间：2023-10-21 22:07:35浏览次数：36  
标签：继承 基类 C++ class Person 派生类 public

一、继承的概念与定义

1、继承的概念

继承机制是面向对象程序设计实现代码复用的重要手段，它允许程序员在保持原有类特性的基础上进行拓展，增加功能，我们把原本的类称之为父类或者基类，新产生的类称之为子类或者派生类。继承体现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。

下面这段代码里，派生类Student类和Teacher类继承了基类Person类后，Person类的成员（成员变量+成员函数）都会成为派生类的一部分，所以即使我们没有在Student类和Teacher类中定义函数与变量，却仍然能调用Printf函数打印个人信息。

class Person
{
public:
	void Printf()//打印个人信息
	{
		cout << "name: " << _name << endl;
		cout << "age: " << _age << endl;
		cout << "sex: " << _sex << endl;
	}
protected:
	string _name = "Nesta";//名字
	int _age = 23;//年龄
	string _sex = "男";//性别
};

class Student :public Person//学生类
{
protected:
	string _stuid;//学号
};

class Teacher :public Person//老师类
{
protected:
	string _jobid;//工号
};

void Test1()
{
	Person p;
	p.Printf();
	Student s;
	s.Printf();
	Teacher t;
	t.Printf();
}

C++中的继承_虚拟继承

2、继承的定义

2.1、定义格式

下图的Student是派生类，Person是基类。

C++中的继承_构造函数_02

2.2、继承方式与访问限定符

C++中的继承_继承_03

2.3、继承基类成员访问权限的变化

不同的继承方式，可能会导致我们从基类继承而来的成员访问权限发生变化。

类成员/继承方式

public继承

protected继承

private继承

基类的public成员

派生类中的public成员

派生类中的protected成员

派生类中的private成员

基类的protected成员

派生类中的protected成员

派生类中的protected成员

派生类中的private成员

基类的private成员

在派生类中不可见

在派生类中不可见

在派生类中不可见

总结：

①基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。

②基类private成员在派生类中是不能被访问的，如果基类成员不想在类外被直接访问，但需要在派生类中能被访问，就定义为protected。可以看出protected成员限定符是因为继承才出现的。

③观察上面的表格可以发现，基类的private成员在子类中都是不可见的，基类的其他成员在子类中的访问权限=Min（成员在基类的访问权限，继承方式），public>protected>private。

④如果不显示地写出继承方式，使用关键字class是默认的继承方式是private，使用struct时默认的继承方式是public。

⑤在实际运用中一般使用的都是public继承，几乎很少用protected/private继承，也不提倡使用使用protected/private继承，因为protected/private继承下来的成员都只能在派生类里使用，实际中拓展维护性不强。

二、基类和派生类对象赋值转换

  • 派生对象可以赋值给基类的对象/基类的指针/基类的引用。这种行为被称之为切片或者切割，寓意把派生类中父类的那部分切来赋值过去。
  • 基类对象不能赋值给派生类对象
  • 基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类的指针是指向派生类对象时才是安全的

C++中的继承_继承_04

class Person
{
public:
	void Printf()//打印个人信息
	{
		cout << "name: " << _name << endl;
		cout << "age: " << _age << endl;
		cout << "sex: " << _sex << endl;
	}
protected:
	string _name = "Nesta";//名字
	int _age = 23;//年龄
	string _sex = "男";//性别
};
class Student :public Person//学生类
{
protected:
	string _stuid;//学号
};
void Test2()
{
	Student s1;
	//派生对象可以赋值给基类的对象/基类的指针/基类的引用
	Person p1 = s1;
	Person* p2 = &s1;
	Person& p3 = s1;
	//基类对象不能赋值给派生类对象
	s1 = p1;//报错
	//基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用
	Student* s2 = (Student*)p2;
	Student& s3 = (Student&)p3;
}

三、继承中的作用域

  1. 在继承体系中基类和派生类都有独立的作用域。、
  2. 基类和派生类中有同名成员，派生类成员将屏蔽对基类同名成员的直接访问，这种情况叫隐藏，也叫重定义。（在派生类中可以用 基类::基类成员 显示访问）。
  3. 如果是成员函数的隐藏，只需要函数名相同就构成隐藏（参数和返回值不用相同）。
  4. 在实际运用中最好不要定义同名的成员。

下面这段代码里，Person和Student的成员变量_id构成了隐藏，这样写代码语法上没有任何问题，但是非常容易混淆。

class Person
{
protected:
	string _name = "Nesta";//名字
	int _age = 23;//年龄
	string _id = "100001";//编号
};
class Student :public Person//学生类
{
public:
	void Printf()//打印个人信息
	{
		cout << "name: " << _name << endl;
		cout << "age: " << _age << endl;
		cout << "id: " << _id << endl;
	}
protected:
	string _id="120002";//编号
};

如果想要访问被隐藏的成员变量，可以像下面这样访问：

cout << "Person:id: " << Person::_id << endl;

下面这段代码不仅Person和Student的成员变量_id构成了隐藏，成员函数Printf也构成了隐藏。

class Person
{
public:
	void Printf()//基类的Printf函数
	{
		cout << "name: " << _name << endl;
		cout << "age: " << _age << endl;
		cout << "id: " << _id << endl;
	}
protected:
	string _name = "Nesta";//名字
	int _age = 23;//年龄
	string _id = "100001";//编号
};
class Student :public Person//学生类
{
public:
	void Printf()//派生类的Printf函数
	{
		cout << "name: " << _name << endl;
		cout << "age: " << _age << endl;
		cout << "id: " << _id << endl;
	}
protected:
	string _id="120002";//编号
};
void Test1()
{
	Student s;
	s.Printf();
    //基类的Printf函数被隐藏了，
    //所以派生类对象直接访问的是派生类的Printf函数
	s.Person::Printf();
    //显示访问被隐藏的基类Printf函数
    //此时有两个_id,一个是被隐藏的基类的_id，一个是派生类的_id
    //从基类继承而来的函数只能调用基类的成员。
    //所以这个Printf函数打印的_id，是被隐藏的_id
}

C++中的继承_继承_05

四、派生类的默认函数

  1. 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。
  2. 派生类的拷贝构造函数必须调用基类的拷贝构造函数完成基类的拷贝初始化。
  3. 派生类的operator=必须调用基类的operator=完成基类的复制。
  4. 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理，基类对象后清理的顺序。
  5. 派生类对象初始化先调用基类的构造函数再调用派生类的构造函数。
  6. 派生类对象析构清理先调用派生类的析构函数再调用基类的析构函数。
  7. 编译器会对基类与派生类的析构函数函数名进行特殊处理，处理成destructor()，所以基类和派生类的析构函数会构成隐藏关系。、

C++中的继承_构造函数_06


C++中的继承_继承_07

class Person
{
public:
	Person(const string& name = "Nesta")//构造函数
		:_name(name)
	{
		cout << "Person()" << endl;
	}
	Person(const Person& p)//拷贝构造
		:_name(p._name)
	{
		cout << "Person(const Person& p)" << endl;
	}
	Person& operator=(const Person& p)//赋值重载
	{
		if (this != &p)
		{
			_name = p._name;
		}
		cout << "Person& operator=(const Person& p)" << endl;
		return *this;
	}
	~Person()//析构函数
	{
		cout << "~Person()" << endl;
	}
protected:
	string _name;//名字
};

class Student :public Person//学生类
{
public:
	Student(const string& name = "Nesta",const string& stuid = "20220813")
		:Person(name)//调用基类的构造函数初始化基类那一部分成员
		,_stuid(stuid)
	{
		cout << "Student(const string& name,const string& stuid)" << endl;
	}
	Student(const Student& s)
		:Person(s)////调用基类的拷贝构造函数初始化基类那一部分成员
		, _stuid(s._stuid)
	{
		cout << "Student(const Student& s)" << endl;
	}
	Student& operator=(const Student& s)
	{
		if (this != &s)
		{
			Person::operator=(s);
			_stuid = s._stuid;
		}
		cout << "Student& operator=(const Student& s)" << endl;
		return *this;
	}
	~Student()
	{
		cout << "~Studnt()" << endl;
	}

protected:
	string _stuid="120002";//学号
};
void Test1()
{
	Student s("Nesta","20220813");
	Student s2(s);
}
void Test1()
{
	Student s("Nesta","20020813");
	Student s2(s);
	Student s3("Kaka", "20030822");
	s3 = s;
}

C++中的继承_继承_08

五、继承与友元

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

class Student;
class Person
{
public:
	friend void Display(const Person& p, const Student& s);
protected:
	string _name = "Nesta";//名字
};

class Student :public Person//学生类
{
protected:
	string _stuid = "20020813";//学号
};

void Display(const Person& p,const Student& s)
{
	cout << p._name;
	cout << s._stuid;//这句代码会报错
	cout << s._name;//不会报错
}

六、继承与静态成员

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

class Person
{
public:
	Person()
	{
		++_count;
	}
protected:
	string _name = "Nesta";//名字
public:
	static int _count;
};
int Person::_count = 0;
class Student :public Person//学生类
{
protected:
	string _stuid = "20020813";//学号
};
class Graduate :public Student
{
protected:
	string _seminarCourse;//研究科目
};
void Test1()
{
	Person p;
	Student s;
	Graduate g;
	Student s1;
	Student s2;
	cout << Person::_count;
}

C++中的继承_继承_09

七、菱形继承与菱形虚拟继承

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

C++中的继承_虚拟继承_10

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

C++中的继承_构造函数_11

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

C++中的继承_虚拟继承_12

菱形继承的问题：从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题。在Graduate对象中Person成员会有两份。

C++中的继承_菱形继承_13

class Person
{
:
	string _name = "Nesta";//名字
};
class Student :public Person
{
protected:
	string _stuid = "20020813";//学号
};
class Teacher :public Person
{
protected:
	string _jobid = "20030822";//工号
};
class Graduate :public Student,public Teacher
{
protected:
	string _seminarCourse;//研究科目
public:
};
void Test1()
{
	Graduate g;
	cout << g._name;//报错
	//这样写有二义性，不知道访问Student还是Teacher里的_name
	cout << g.Student::_name;
	cout << g.Teacher::_name;
	//需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
}

虚拟继承可以解决菱形继承的二义性和数据冗余的问题。如上面的关系，在Student和Teacher的继承Person时使用虚拟继承，即可解决问题。注意，虚拟继承不要再其他的地方使用。

class Person
{
public:
	string _name = "Nesta";//名字
};
class Student :virtual public Person//虚拟继承
{
protected:
	string _stuid = "20020813";//学号
};
class Teacher :virtual public Person//虚拟继承
{
protected:
	string _jobid = "20030822";//工号
};
class Graduate :public Student,public Teacher
{
protected:
	string _seminarCourse;//研究科目
};
void Test1()
{
	Graduate g;
	cout << g._name;//此时没有问题
}

为什么虚拟继承能够解决菱形继承数据冗余与二义性的问题呢？

先看下面这段代码，这里的菱形继承没有使用虚拟继承

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 Test2()
{
	D d;
	d.B::_a = 1;
	d.C::_a = 2;
	d._b = 3;
	d._c = 4;
	d._d = 5;
}

从d的内存分布可以看到数据冗余。

C++中的继承_构造函数_14

下面这段代码，这里的菱形继承使用了虚拟继承

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 Test2()
{
	D d;
	d.B::_a = 1;
	d.C::_a = 2;
	d._b = 3;
	d._c = 4;
	d._d = 5;
}

从下图的内存分布可以看出，D对象中将A放到了对象组成的最下面，这个A同时属于B和C，那么B和C如何去寻找公共的A呢？这里通过B和C里的两个指针，指针指向的一张表。这两个指针叫虚基表指针，这两个表叫虚基表。虚基表中存放着偏移量，通过偏移量可以找到下面的A。

C++中的继承_构造函数_15



结束。。。


标签：继承,基类,C++,class,Person,派生类,public
From： https://blog.51cto.com/u_15855358/7969576

相关文章

  • vs 禁用c++编译警告提示的两种方式
    1.禁用单个cpp文件编译警告#pragmawarning(disable:警告号)如：当前提示C4305警告;加入禁用单个cpp文件编译警告;结果：编译警告消失.2.全局禁用指定警告效果如下 翻译搜索复制......
  • C++变量类型
    C++变量类型变量的名称可以由字母、数字和下划线组成。它必须以字母或下划线开头。类型描述bool布尔类型，存储值为true或false，占用1个字节char字符类型，用于存储ASCII字符，通常占用1个字节int整数类型，通常用于存储普通整数，通常占用四个字节float单精度浮点值......
  • C/C++ C2679 二元“<<”: 没有找到接受“XXX”类型的右操作数的运算符(或没有可接受的
    今天在做一个C++项目时遇到了如下问题： 找了好久的百度，结果发现只要把这段报错的程序换一下位置，放到运算符重载函数的下面就可以了，因为编译器是按顺序执行的。。。 ......
  • c++指针相关
    常量指针(PointertoConstant)定义：一个指向常量的指针。这意味着指针指向的值不能被修改，但指针本身可以被修改，即可以重新指向其他地址。声明：constType*pointerName;constint*p1;intx=10,y=20;p1=&x;//Valid*p1=50;//Errorp1=&y;//Valid指针......
  • c++默认实参
    参考：默认实参#include<iostream>voidf(inta,intb=1);//只要前面声明了b的值，后面b可以不给默认值voidf(inta=2,intb){std::cout<<a<<''<<b<<'\n';}intmain(){f();}......
  • C++ 使用EPSG进行坐标转换
    场景将WGS84坐标转换为CGCS2000坐标使用epsg.io网站的坐标系转换功能可以检查转换结果是否正确下面网址是示例代码https://epsg.io/transform#s_srs=4326&t_srs=4538&x=88.0000000&y=47.0000000转换示例代码projver.9.2.0安装proj库，使用vcpkg(vcpkginstallproj:x64-wind......
  • VSCode配置Clang C/C++开发环境 [+clangd代码静态检查配置]
    问题：gcc/g++是c/c++使用最广泛的编译器，也是linux默认自带的编译套件，但在vscode上，也可通过微软官方提供的C/C++插件很便捷进行c/c++代码编译调试，但是该插件的自动补全和代码提示等功能很差，经常给不出合理的候选项。另外一套C/C++代码编译套件是基于LLVM的clang/clang++编译器、ll......
  • 8.1 C++ 标准输入输出流
    C/C++语言是一种通用的编程语言，具有高效、灵活和可移植等特点。C语言主要用于系统编程，如操作系统、编译器、数据库等；C语言是C语言的扩展，增加了面向对象编程的特性，适用于大型软件系统、图形用户界面、嵌入式系统等。C/C++语言具有很高的效率和控制能力，但也需要开发人员自行管理内存......
  • 8.2 C++ 引用与取别名
    C/C++语言是一种通用的编程语言，具有高效、灵活和可移植等特点。C语言主要用于系统编程，如操作系统、编译器、数据库等；C语言是C语言的扩展，增加了面向对象编程的特性，适用于大型软件系统、图形用户界面、嵌入式系统等。C/C++语言具有很高的效率和控制能力，但也需要开发人员自行管理内存......
  • 8.3 C++ 定义并使用类
    C/C++语言是一种通用的编程语言，具有高效、灵活和可移植等特点。C语言主要用于系统编程，如操作系统、编译器、数据库等；C语言是C语言的扩展，增加了面向对象编程的特性，适用于大型软件系统、图形用户界面、嵌入式系统等。C/C++语言具有很高的效率和控制能力，但也需要开发人员自行管理内存......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99