c++--继承

“αβ”

已于 2024-07-28 09:58:38 修改

阅读量927

点赞数 10

分类专栏： c++ 文章标签： c++ 继承

于 2024-07-25 22:45:02 首次发布

本文链接：https://blog.csdn.net/2301_81265915/article/details/140690372

版权

c++ 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

前言

c++作为面向对象的语言三大特点其中之一就是继承，那么继承到底有何奥妙呢？那么这篇文章将会为您揭晓，写的不好的地方还请指出，谢谢。

继承的概念及定义

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

例如，以下代码中Student类和Teacher类就继承了Person类

//父类
class Person
{
public:
    void Print()
	{
		cout << "name:" << _name << endl;		
	}
protected:
	string _name;
};

//子类
class student : public Person
{
public:
    void Print()
	{
		cout << "id:" << _id<< endl;
	}
protected:
	int _id;
};

继承后，父类Person的成员，包括成员函数和成员变量，都会变成子类的一部分，也就是说，子类Student会作为Person的儿子继承“父亲”的衣钵，去复用了父类Person的成员。

继承的定义

定义格式

继承的定义格式如下：

说明： 在继承当中，父类也称为基类，子类是由基类派生而来的，所以子类又称为派生类。

但如果父类是由另一个类继承而来，那么父类也可以作为派生类。

继承方式和访问限定符

在c++类的介绍中我们知道，访问限定符有以下三种：

public访问限定符
protected访问限定符
private访问限定符

同样来说，类的继承方式也是存在着三种：

public继承
protected继承
private 继承

观察细心的话，会发现，这里是没有使用private，而是使用了protected，在c++类的初始介绍文章中说过，在开始使用的时候写protected与private都是一样的，都没有区别，但是在继承里面都不一样了，会有很大区别，

下面不卖关子，开始一点一点开始介绍

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

基类当中被不同访问限定符修饰的成员，以不同的继承方式继承到派生类当中后，该成员最终在派生类当中的访问方式将会发生变化。

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

看完表格为了更好的理解，这里举一个例子

为了方便将继承方式名为圈。

按照上表的标准来说，如果圈内填写的是protected，那么对应的protected继承规则就是基类public会被集成到派生类的public，基类protected会被集成到派生类的protected，而基类的private在派生类不可见，这就意味着，在子类中会继承出父类的public，protected

这样一解释是不是就很清楚了呢？

但是归根到底这个表格看起来都麻烦，那么怎么去记忆呢？

稍作观察，实际上基类成员访问方式的变化规则也不是无迹可寻的，我们可以认为三种访问限定符的权限大小为：public > protected > private，基类成员访问方式的变化规则如下：

在基类当中的访问方式为public或protected的成员，在派生类当中的访问方式变为：Min(成员在基类的访问方式，继承方式)。
在基类当中的访问方式为private的成员，在派生类当中都是不可见的。

基类的private成员在派生类当中不可见是什么意思？

我们知道，在类中的private里面的内容是只属于这个类的内容，仅此而已，在类外是无法直接访问的。例如，虽然Student类继承了Person类，但是我们无法在Student类当中访问Person类当中的private成员_name。

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

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

总结：所以在日常使用继承的时候一般都是，将基类中想要被继承成员用protected修饰，以public为继承方式，几乎很少使用protected和private继承，也不提倡使用protected和private继承，因为使用protected和private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。

默认继承方式

但在日常使用继承的情况下不免会忘记写继承方式，又或者说会看到不写继承方式的继承代码，可能下意识会觉得是错误的，但其实是正确的，c++中存在着默认的继承方式。

就比如说：使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public。

所继承的基类成员_name的访问方式变为private。

//父类
class Person
{
public:
	//...
protected:
	//...
private:
	string _name = "张三";
};

//子类
class student : Person//默认为private继承
{
public:
	void Print()
	{
		cout << "id:" << _id << endl;
	}
protected:
	int _id;
};

而在关键字为struct的派生类当中，所继承的基类成员_name的访问方式仍为public。

//父类
class Person
{
public:
	//...
protected:
	//...
private:
	string _name = "张三";
};

//子类
struct student : Person//默认为public继承
{
public:
	void Print()
	{
		cout << "id:" << _id << endl;
	}
protected:
	int _id;
};

注意： 虽然继承时可以不指定继承方式而采用默认的继承方式，但还是最好显示的写出继承方式。

继承对派生类对象的影响

上面，朦胧的介绍了继承的继承方式与定义，那么继承到底会对派生类对象造成什么影响呢？

//父类
class Person
{
protected:
	string _name = "张三";
};

//子类
struct student : public Person//默认为public继承
{
protected:
	int _id;
};
int main()
{
	Person p;
	student s;
	return 0;
}

对于这个代码，看过上面，就可以知道基类的protected中的_name会被基类访问继承，这样就会导致student对象会不在存在一个成员，还会存在一个_name;（注意s的_name是张三）

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

派生类对象可以赋值给基类的对象、基类的指针以及基类的引用，因为在这个过程中，会发生基类和派生类对象之间的赋值转换。

在普通的类型中，我们知道引用不同对象之间的赋值，如果存在隐式类型转换，其实会在中间产生一个中间变量，这个中间变量具有常性，为了避免权限放大的问题，其左操作数一般要用const修饰。但是类的继承就不存在这种问题，即使二者不是同种类存在隐式类型转换也没关系。

在实际上是因为，在c++规则默认上认为将派生类赋值给基类，中间是不产生临时对象的，这一规定被叫做父子类赋值兼容规则（切割/切片）

例如，对于以下基类及其派生类。

//基类
class Person
{
protected:
	string _name; //姓名
	string _sex;  //性别
	int _age;     //年龄
};
//派生类
class Student : public Person
{
protected:
	int _class;   //班级
};

可以对上面代码进行这类逻辑操作：

Student s;

Person p = s; //派生类对象赋值给基类对象

Person* ptr = &s; //派生类对象赋值给基类指针

Person& ref = s; //派生类对象赋值给基类引用

在实际的物理空间上Student的类的成员是比Person多的，对于上面的操作，将多的赋值给少的（基类），这类行为称为切片/切割，寓意把派生类中基类那部分切来赋值过去。派生类对象赋值给基类对象图示：

Person p = s; //派生类对象赋值给基类对象

Person* ptr = &s; //派生类对象赋值给基类指针

Person& ref = s; //派生类对象赋值给基类引用

注意： 基类对象不能赋值给派生类对象（只能切割），基类的指针可以通过强制类型转换赋值给派生类的指针，但是此时基类的指针必须是指向派生类的对象才是安全的。

继承中的作用域

在继承体系中的基类和派生类都有独立的作用域。若子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。

例如，对于以下代码，访问成员_name时将访问到子类当中的_name。

#include<iostream>
#include<string>
using namespace std;
//父类
class Person
{
protected:
	string _name = "李四";
};
//子类
class Student : public Person
{
public:
	void fun()
	{
		cout << _name << endl;
	}
protected:
	string _name = "张三";
};
int main()
{
	Student s;
	s.fun(); //会打印张三
	return 0;
}

虽然在派生类中即使继承了基类的_name但是，还是会被子类的成员屏蔽父类的同名成员的直接访问，这就叫做隐藏。

但如果还是可以通过指定命名空间，专门打印基类的同名成员，

	void fun1()
	{
		cout << Person::_name << endl; //指定访问父类当中的_name成员
	}

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

就比如对于以下代码，调用成员函数fun时将直接调用子类当中的fun，若想调用父类当中的fun，则需使用作用域限定符指定类域。

#include<iostream>
#include<string>
using namespace std;
//父类
class Person
{
public:
	void fun(double a = 5.5)
	{
		cout << "Person::_name" << endl;
	}
protected:
	string _name = "李四";
};
//子类
class Student : public Person
{
public:
	void fun(int a=5)
	{
		cout << "Student::_name" << endl;
	}
protected:
	string _name = "张三";
};

int main()
{
	Student s;
	s.fun(); //会打印：Student::_name
	s.Person::fun();//会打印：Person::_name
	return 0;
}

特别注意： 代码当中，父类中的fun和子类中的fun不是构成函数重载，因为函数重载要求两个函数在同一作用域，而此时这两个fun函数并不在同一作用域。为了避免类似问题，实际在继承体系当中最好不要定义同名的成员。

派生类的默认成员函数

派生类作为类的一种特别的类，他也是符合类的基本要求的，也是有类的六个默认成员函数，即使我们不去写，也还是会生成的默认成员函数。

对于基类的默认成员函数的逻辑如下：

//基类
class Person
{
public:
	//构造函数
	Person(const string& name = "张三")
		:_name(name)
	{
		cout << "Person()" << endl;
	}
	//拷贝构造函数
	Person(const Person& k)
		:_name(k._name)
	{
		cout << "Person(const Person& k)" << endl;
	}
	//赋值运算符重载函数
	Person& operator=(const Person& k)
	{
		cout << "Person& operator=(const Person& k)" << endl;
		if (this != &k)
		{
			_name = k._name;
		}
		return *this;
	}
	//析构函数
	~Person()
	{
		cout << "~Person()" << endl;
	}
private:
	string _name; //姓名
};

那么对于派生类的六大成员函数的代码逻辑实现如下：

//子类
class Student : public Person
{
public: 
	//构造函数
	Student(const string& name, int age)
		:Person(name)//调用初始化基类的构造函数去初始化基类那一部分的成员
		,_age(age)//初始化派生类的成员
	{
		cout << "Student()" << endl;
	}
	//拷贝构造函数
	Student(const Student& s)
		:Person(s)调用初始化基类的拷贝函数去拷贝基类那一部分的成员
		//同样传s也涉及到了切割的基本原则
		,_age(s._age)//拷贝派生类的成员
	{
		cout << "Student(const Student& s)" << endl;
	}
	//赋值运算符重载函数
	Student& operator=(const Student& k)
	{
		cout << "Student& operator=(const Student& k)" << endl;
		if (this != &k)
		{
			Person::operator=(k); //调用基类的operator=完成基类成员的赋值
			_age = k._age; //完成派生类成员的赋值
		}
		return *this;
	}
	//析构函数
	~Student()
	{
		cout << "~Student()" << endl;
		//~Person();会自动调用先调用派生类的，后自动调用基类
		//派生类的析构函数会在被调用完成后自动调用基类的析构函数
	}
protected:
	int _age;
};

派生类与普通类的默认成员函数的不同之处概括为以下几点：

派生类的构造函数被调用时，会自动调用基类的构造函数初始化基类的那一部分成员，如果基类当中没有默认的构造函数，则必须在派生类构造函数的初始化列表当中显示调用基类的构造函数。
派生类的拷贝构造函数必须调用基类的拷贝构造函数完成基类成员的拷贝构造。
派生类的赋值运算符重载函数必须调用基类的赋值运算符重载函数完成基类成员的赋值。
派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。
派生类对象初始化时，会先调用基类的构造函数再调用派生类的构造函数。
派生类对象在析构时，会先调用派生类的析构函数再调用基类的析构函数。

补充以下几点：

1：同样赋值运算符重载函数也是存在函数名相同，同样也是构成了隐藏的关系，如果想要调用基类的赋值运算符重载函数，要指定作用域

2：由于多态的某些原因，任何类的析构函数名都会被统一处理为destructor();。因此，派生类和基类的析构函数也会因为函数名相同构成隐藏，若是我们需要在某处调用基类的析构函数，那么就要使用作用域限定符进行指定调用。

需要注意一点的是析构的顺序，对于派生类的析构函数，会进行优化，会先析构派生类，后析构基类，这样的顺序是因为，如果先进行析构基类，后再进行析构派生类，那么就会对继承的基类的那一部分造成二次析构，但是如果套娃式的继承多层，那么最底层的析构次数将会多的不敢想象。

继承与静态成员

若基类当中定义了一个static静态成员变量，则在整个继承体系里面只有一个该静态成员。无论派生出多少个子类，都只有一个static成员实例。

就比如下面的代码，利用_count计算一共走了几次构造函数，

class Person
{
public:
	static int _count; //统计人的个数。
	Person()
	{
		_count++;
	}
	void print()
	{
		cout << _count << endl;
	}
protected:
	string _name;
};
int Person::_count = 0;
class Student : public Person
{
public:
	Student()
	{
		_count++;
	}
protected:
	int _age;
};
int main()
{
	Person p;
	Student s;
	s.print();//3
	p.print();//3
	return 0;
}

可以看见确实是公用一个_count的，这里打印的是3，其实也是上面知识的利用，不明白的看看前面的成员函数就明白了；

继承的方式

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

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

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

对于前两种继承方式就不多说了，c++作为第一个面向对现象的高级语言，在设计时时从0->1，这一步没有任何借鉴，所以导致在设计继承时就产生了菱形继承，这就导致了很多问题，就比如说，Person中有一个_name的成员，通过继承Studen与Teacher也会通过访问继承_name，但是对于Assistant，就麻烦了，他要访问继承Student的_name还是Teacher的_name呢？

所以就会Assistant对象的_name成员会出现访问不明确的报错。

当然可以通过点名指定要继承谁的，但是这对于一个编程来说是太过于麻烦而不及的，无法彻底解决这一问题，因为在Assistant的对象在Person成员始终会存在两份。归根到底还是会导致二义性，重复的问题。

但是好在c++祖师爷为了填坑，又自己挖了点土把坑填上了，这也就导致Java，c#都不存在菱形继承这一方式。

菱形虚拟继承

菱形虚拟继承就是解决了菱形继承的二义性和数据冗余问题。

对菱形继承的修改就是在类的继承方式前面加上 virtual

class Person
{
public:
	string _name; //姓名
};
class Student : virtual public Person //虚拟继承
{
protected:
	int _num; //学号
};
class Teacher : virtual public Person //虚拟继承
{
protected:
	int _id; //职工编号
};
class Assistant : public Student, public Teacher
{
protected:
	string _majorCourse; //主修课程
};
int main()
{
	Assistant a;
	a._name = "张三"; //无二义性
	return 0;
}

此时就可以直接访问Assistant对象的_name成员了，并且之后就算我们指定访问Assistant的Student父类和Teacher父类的_name成员，访问到的都是同一个结果，解决了二义性的问题。

而我们要是打印Assistant的Student父类和Teacher父类的_name成员的地址时，显示的也是同一个地址，解决了数据冗余的问题。

虚拟继承前后对比

在没有学虚拟继承时，我们定义一个如下的菱形继承

class A
{
public:
	int a;
};
class B : public A
{
protected:
	int b;
};
class C: public A
{
protected:
	int c;
};
class D: public B, public C
{
protected:
	int d;
};

对于D对象中各个成员在内存当中的分布情况如下：

这里就可以看出为什么菱形继承导致了数据冗余和二义性，根本原因就是D类对象当中含有两个_a成员。

现在我们再来看看使用菱形虚拟继承时，以下菱形继承当中D类对象的各个成员在内存当中的分布情况。

修改后的代码：

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

其物理空间如下：

可以明显看出虚拟继承的处理方式还是比较明了的。

总结

很多人说c++难，其中难的一个原因就是他有很多坑，比如c++98设计的东西，突然在后面发现了，但没有特别好的改进方法，这就会导致有一些很让人想不明白的解决方法就产生了，有的解释学起来很符合逻辑，但有的解释他虽然符合逻辑，但是十分难理解。

就比如说菱形继承，底层实现就很复杂。所以一般不建议设计出菱形继承，否则代码在复杂度及性能上都容易出现问题，当菱形继承出问题时难以分析，并且会有一定的效率影响。

继承这部分还没有彻底体现出来菱形继承的复杂之处，在多态里面的虚表，哎，那菱形继承会让你知道什么叫难，好在这一点过于复杂，只是了解内容，哈哈哈。

补充内容：

继承和组合

继承是一种is-a的关系，也就是说每个派生类对象都是一个基类对象；而组合是一种has-a的关系，若是B组合了A，那么每个B对象中都有一个A对象。

例如，车类和宝马类就是is-a的关系，它们之间适合使用继承。

class Car
{
protected:
	string _colour; //颜色
	string _num; //车牌号
};
class BMW : public Car
{
public:
	void Drive()
	{
		cout << "this is BMW" << endl;
	}
};

而车和轮胎之间就是has-a的关系，它们之间则适合使用组合。

class Tire
{
protected:
	string _brand; //品牌
	size_t _size; //尺寸
};
class Car
{
protected:
	string _colour; //颜色
	string _num; //车牌号
	Tire _t; //轮胎
};

若是两个类之间既可以看作is-a的关系，又可以看作has-a的关系，则优先使用组合。

原因如下：

继承允许你根据基类的实现来定义派生类的实现，这种通过生成派生类的复用通常被称为白箱复用(White-box
reuse)。术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对于派生类可见，继承一定程度破坏了基类的封装，基类的改变对派生类有很大的影响，派生类和基类间的依赖性关系很强，耦合度高。
组合是类继承之外的另一种复用选择，新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口，这种复用风格被称之为黑箱复用(Black-box reuse)，因为对象的内部细节是不可见的，对象只以“黑箱”的形式出现，组合类之间没有很强的依赖关系，耦合度低，优先使用对象组合有助于你保持每个类被封装。
实际中尽量多使用组合，组合的耦合度低，代码维护性好。不过继承也是有用武之地的，有些关系就适合用继承，另外要实现多态也必须要继承。若是类之间的关系既可以用继承，又可以用组合，则优先使用组合。

基类哪些数据会被子类继承下来?

1.子类会从基类继承下来的所有数据

1) 基类中的每个数据成员（尽管子类不一定都能访问，即便是私有的成员也会继承下来，能不能访问到是另一回事）
2) 基类中的每个普通成员函数（尽管子类不一定都能访问）
3) 与基类相同的初始数据层

2.子类不会继承的基类的数据

1) 基类的构造函数与析构函数
2) 基类的友元

“αβ”

关注

10
点赞
踩
20

收藏

觉得还不错? 一键收藏
0
评论
c++--继承

c++作为面向对象的语言三大特点其中之一就是继承，那么继承到底有何奥妙呢？继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用，继承就是类方法的复用。
复制链接

扫一扫

专栏目录