C++：类和对象：继承

最新推荐文章于 2023-11-13 10:30:00 发布

FishAnd_Yu

最新推荐文章于 2023-11-13 10:30:00 发布

阅读量830

点赞数 1

分类专栏： # C++精华文章标签： c++ 继承

本文链接：https://blog.csdn.net/u013620306/article/details/128372258

版权

C++精华专栏收录该内容

50 篇文章 19 订阅

订阅专栏

前言：

继承时面向对象额三大特性之一：

在面向对象中，有些类与类之间存在特殊关系，下级别的类除了拥有上一级别的共性，还有自己的特性，这个时候我们就需要考虑利用继承的技术减重复代码。

1：继承好处：可以减少重复的代码。

2：继承的语法：class A : public B

------》A类称为子类或派生类

------》B类称为父类或基类

3：派生类中的成员，包含两大部分。

------》一部分是从基类继承过来的，一部分是自己增加的成员

-----》从基类继承过来的，表现为共性，而新增的成员体现其个性。

1：继承方式

继承一共有三种方式

1：公共继承 public

父类中的公共权限成员，到子类中还是公共权限

父类中保护权限成员，到子类中是保护权限

父类中私有权限成员，子类中是不可访问的

2: 保护继承 protected

父类中的公共权限成员，到子类中变成保护权限

父类中保护权限成员，到子类中是保护权限

父类中私有权限成员，子类中是不可访问的

3: 私有继承 private

父类中的公共权限成员，到子类中变成私有权限

父类中保护权限成员，到子类中是私有权限

父类中私有权限成员，子类中是不可访问的

这三种继承方式中，子类和父类的各种权限的成员之间的关系如下。

2：继承中的对象模型

问题：从父类继承过来的成员，哪些属于子类对象中？

答案：父类中的所有非静态成员属性都会被子类继承下来

父类中私有成员属性被编译器隐藏，因此访问不到，但是确实被进继承下来。

#include<iostream>
#include<string>
using namespace std;

class Base {
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};

class Sub :public Base {
public:
	int m_D;
};

int main() {
	cout << "sizeof sub =" << sizeof(Sub) << endl;
	return 0;
}

运行结果可知：

子类拥有16字节大小数据（即4个 int类型数据）

3：继承中构造和析构顺序

问题：子类继承父类后，当创建子类对象，也会调用父类的构造函数，那么父类和子类的构造、析构函数顺序是怎样的了？

答案：继承中先调用父类的构造函数，在调用子类的构造函数，析构函数的调用顺序正好与构造函数调用顺序相反。

#include<iostream>
#include<string>
using namespace std;

class Base {
public:
	Base() {
		cout << "调用Base构造函数" << endl;
	}
	~Base()
	{
		cout << "调用Base析构函数" << endl;
	}
};

class Son :public Base {
public:
	Son() {
		cout << "调用Son构造函数" << endl;
	}

	~Son()
	{
		cout << "调用Son析构函数" << endl;
	}
};

int main() {
	Son s;
	return 0;
}

4：继承同名成员的处理方式

问题：当子类与父类出现同名的成员，如何通过子类对象，访问到子类或者父类中同名的数据？

答案：通过子类对象，直接访问同名成员，就是访问的子类数据

通过子类对象，如果加上父类作用域，那么就是访问的父类数据。

#include<iostream>
#include<string>
using namespace std;

class Base {
public:
	Base() {
		cout << "调用Base构造函数" << endl;
		m_A = 100;
	}
	~Base()
	{
		cout << "调用Base析构函数" << endl;
	}
	int m_A;

	void func() {
		cout << "Base父类的 func 函数调用了" << endl;
	}

};

class Son :public Base {
public:
	Son() {
		cout << "调用Son构造函数" << endl;
		m_A = 200;
	}

	~Son()
	{
		cout << "调用Son析构函数" << endl;
	}

	void func() {
		cout << "Son子类的 func 函数调用了" << endl;
	}
};

int main() {
	Son s;
	cout << "Son的 m_A是：" << s.m_A << endl;
	cout << "Base的 m_A是：" << s.Base::m_A << endl;
	s.func();
	s.Base::func();
	return 0;
}

问题：如果父类的重名成员函数发生了重载，要想访问父类同名成员函数，该怎么办？

答案：因为子类中出现和父类同名的成员函数，所以子类的同名函数会隐藏父类中所有的同名函数（包括重载），所以要想访问到父类中被隐藏的同名函数，就需要加作用域

或者，子类将同名的成员函数删除。

5：继承同名的静态成员处理方式

问题：继承中同名的静态成员在子类对象上如何进行访问。

答案：同名静态成员处理方式和非静态处理方式一样，通过添加作用域即可访问，只不过同名静态成员有两种访问的方式（通过对象和通过类名）。

#include<iostream>
#include<string>
using namespace std;
class Base {
public:
	static int m_A;
};
int Base::m_A = 100;

class Son :public Base {
public:
	static int m_A;
};
int Son::m_A = 200;

void test() {
	// 1： 通过对象访问
	cout << "通过对象访问静态成员" << endl;
	Son s;
	cout << "Son 下 m_A = " << s.m_A << endl;
	cout << "Base 下 m_A = " << s.Base::m_A << endl;

	// 2: 通过类名访问
	cout << "通过类名访问静态成员" << endl;
	cout << "Son下 m_A = " << Son::m_A << endl;
	// 第一个 :: 代表通过类名方式访问，第二个:: 代表访问父类作用域下
	// 其实也是 可以通过 Base::m_A直接访问的，但是我们这里说的是通过 子类来访问父类的内容
	cout << "Base下 m_A = " << Son::Base::m_A << endl;
}

int main() {
	test();
	return 0;
}

同理：访问同名的静态成员函数也斯一个道理。

6：多继承语法

在C++中允许一个类继承多个类。

语法： class 子类 : 继承方式父类1，继承方式父类2.。。。。

注意：多继承可能引发父类中有同名成员的出现，我们需要加作用域来区分。C++是不建议在开发中使用多继承的。

案例：我们看看多个父类存在同名成员变量的情况

#include<iostream>
#include<string>
using namespace std;
class Base1 {
public:
	Base1() {
		m_A = 100;
	}
	int m_A;
};

class Base2 {
public:
	Base2() {
		m_A = 200;
	}
	int m_A;

};

class Son :public Base1, public Base2 {
public:
	Son() {
		m_C = 300;
		m_D = 400;
	}
	int m_C;
	int m_D;

};

int main() {
	Son s;
	// 不能直接用 s.m_A 访问变量 m_A
	cout << "Base1::m_A = " << s.Base1::m_A << endl;
	cout << "Base2::m_A = " << s.Base2::m_A << endl;
	return 0;
}

运行结果可知：

多继承中如果父类出现了同名情况，子类使用时需要添加作用域。

7：菱形继承

菱形继承概念

1：两个派生类继承同一个基类

2：又有一个类同时继承者两个派生类

这种继承称为菱形继承或者钻石继承。如

菱形继承典型问题：

1：二义性问题：比如羊继承了动物的数据，驼也继承了动物的数据，当羊驼使用数据时，这个时候就会产生二义性问题，当然这个问题可以通过指名： 作用域来解决

2：羊驼继承来自动物的数据有两份，其实我们清楚，这份数据我们只需要一份就可以了，这个问题可以通过 虚继承来解决

案例：看一下菱形继承的子类结构

#include<string>
#include<iostream>
using namespace std;
class Animal {
public:
	int m_Age;
};

class Sheep :public Animal {};
class Tuo :public Animal {};
class SheepTuo :public Sheep, public Tuo {};

void test(){
	SheepTuo st;
	st.Sheep::m_Age = 18;
	st.Tuo::m_Age = 20;
	// 必须带上作用域，如果直接使用 st.m_Age会报错。
	cout << "st.sheep::m_Age = " << st.Sheep::m_Age << endl;
	cout << "st.tuo::m_Age = " << st.Tuo::m_Age << endl;
}

int main() {
	test();
	return 0;
}

利用作用域来解决二义性问题