【c++】类和对象7—继承

于 2023-02-23 17:05:36 发布
阅读量460 收藏
点赞数
分类专栏： c++ 文章标签： c++ java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54007670/article/details/129161912
版权

文章目录

关于继承

我们发现，定义一些类时，下级别的成员处理拥有上一级的共性，还有自己的特性。
这时候我们就可以考虑利用继承的技术，减少重复代码。

继承的好处：减少重复代码

语法：
class 子类 : 继承方法 父类；
如：class A:public B;
A类称为子类或派生类
B类称为父类或基类

派生类中的成员包含两大部分：
一类是从基类继承过来的，一类是自己增加的成员。
从基类继承过来的表现其共性，而新增的成员体现了其个性。

继承与非继承的对比

非继承方式实现：

#include<iostream>
using namespace std;

//Java页面
class Java
{
public:
	void header()
	{
		cout << "首页、公开课、登录...（公共头部）" << endl;
	}
	void footer()
	{
		cout << "帮助中心、交流合作、站内地图...（公共底部）" << endl;
	}
	void left()
	{
		cout << "Java、Python、C++...（公共分类列表）" << endl;
	}
	void content()
	{
		cout << "Java学科视频" << endl;
	}
};

//Python页面
class Python
{
public:
	void header()
	{
		cout << "首页、公开课、登录...（公共头部）" << endl;
	}
	void footer()
	{
		cout << "帮助中心、交流合作、站内地图...（公共底部）" << endl;
	}
	void left()
	{
		cout << "Java、Python、C++...（公共分类列表）" << endl;
	}
	void content()
	{
		cout << "Python学科视频" << endl;
	}
};

//C++页面
class Cpp
{
public:
	void header()
	{
		cout << "首页、公开课、登录...（公共头部）" << endl;
	}
	void footer()
	{
		cout << "帮助中心、交流合作、站内地图...（公共底部）" << endl;
	}
	void left()
	{
		cout << "Java、Python、C++...（公共分类列表）" << endl;
	}
	void content()
	{
		cout << "C++学科视频" << endl;
	}
};

void test()
{
	//Java页面
	cout << "Java下载视频页面如下：" << endl;
	Java ja;
	ja.header();
	ja.footer();
	ja.left();
	ja.content();
	cout << "-----------" << endl;

	//Python页面
	cout << "Python下载视频页面如下：" << endl;
	Python py;
	py.header();
	py.footer();
	py.left();
	py.content();
	cout << "-----------" << endl;

	//C++页面
	cout << "C++下载视频页面如下：" << endl;
	Cpp cp;
	cp.header();
	cp.footer();
	cp.left();
	cp.content();
}

int main()
{
	test();
	system("pause");
	return 0;
}

继承方式实现：

#include<iostream>
using namespace std;

//公共页面
class BasePage
{
public:
	void header()
	{
		cout << "首页、公开课、登录...（公共头部）" << endl;
	}
	void footer()
	{
		cout << "帮助中心、交流合作、站内地图...（公共底部）" << endl;
	}
	void left()
	{
		cout << "Java、Python、C++...（公共分类列表）" << endl;
	}
};

//Java页面
class Java :public BasePage
{
public:
	void content()
	{
		cout << "Java学科视频" << endl;
	}
};

//Python页面
class Python :public BasePage
{
public:
	void content()
	{
		cout << "Python学科视频" << endl;
	}
};

//C++页面
class Cpp :public BasePage
{
public:
	void content()
	{
		cout << "C++学科视频" << endl;
	}
};

void test()
{
	//Java页面
	cout << "Java下载视频页面如下：" << endl;
	Java ja;
	ja.header();
	ja.footer();
	ja.left();
	ja.content();
	cout << "-----------" << endl;

	//Python页面
	cout << "Python下载视频页面如下：" << endl;
	Python py;
	py.header();
	py.footer();
	py.left();
	py.content();
	cout << "-----------" << endl;

	//C++页面
	cout << "C++下载视频页面如下：" << endl;
	Cpp cp;
	cp.header();
	cp.footer();
	cp.left();
	cp.content();
}

int main()
{
	test();
	system("pause");
	return 0;
}

继承方式

继承的语法：class 子类 : 继承方式 父类

C++中的继承方式有：
public、private、protected三种
（它们直接影响到派生类的成员、及其对象对基类成员访问的规则）
（1）public（公有继承）：
继承时保持基类中各成员属性不变，并且基类中private成员被隐藏。
派生类的成员只能访问基类中的public/protected成员，而不能访问private成员；
派生类的对象只能访问基类中的public成员。
（2）protected（保护性继承）：
继承时基类中各成员属性均变为protected，并且基类中private成员被隐藏。
派生类的成员只能访问基类中的public/protected成员，而不能访问private成员；
派生类的对象不能访问基类中的任何的成员。
（3）private（私有继承）：
继承时基类中各成员属性均变为private，并且基类中private成员被隐藏。
派生类的成员只能访问基类中的public/protected成员，而不能访问private成员；
派生类的对象不能访问基类中的任何的成员。

#include<iostream>
using namespace std;

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

class son1 :public dad
{
public:
	void func()
	{
		m_A = 10;//父类中的公共权限成员到子类中 依然是公共权限
		m_B = 20;//父类中的保护权限成员到子类中 依然是保护权限
		//m_C = 30;//父类中的私有权限成员到子类中 访问不到
	}
};

void test01()
{
	son1 s1;
	s1.m_A = 10;
	//s1.m_B = 20;//son1中m_B是保护权限 类外访问不到
}

class son2 :protected dad
{
public:
	void func()
	{
		m_A = 10;//父类中的公共权限成员到子类中 变为保护权限
		m_B = 20;//父类中的保护权限成员到子类中 依然是保护权限
		//m_C = 30;//父类中的私有权限成员到子类中 访问不到
	}
};

void test02()
{
	son2 s2;
	//s2.m_A = 10;//son2中m_A变为保护权限 类外访问不到
	//s2.m_B = 20;//son2中m_B是保护权限 不可访问
}

class son3 :private dad
{
public:
	void func()
	{
		m_A = 10;//父类中的公共权限成员到子类中 变为私有权限
		m_B = 20;//父类中的保护权限成员到子类中 变为私有权限
		//m_C = 30;//父类中的私有权限成员到子类中 访问不到
	}
};

void test03()
{
	son3 s3;
	//s3.m_A = 10;//son3中m_A变为私有权限 类外访问不到
	//s3.m_B = 20;//son3中m_B是私有权限 类外访问不到
}

class grandson3 :public son3
{
public:
	void func()
	{
		//m_A = 10;//到son3中m_A变为私有，即使是儿子也访问不到
		//m_B = 20;//到son3中m_B变为私有，即使是儿子也访问不到
	}
};

int main()
{
	test01();
	test02();
	test02();
	system("pause");
	return 0;
}

继承中的对象模型

#include<iostream>
using namespace std;

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

class son :public dad
{
public:
	int m_D;
};

void test01()
{
	//父类中所有非静态成员属性都会被子类继承下去
	//父类中私有成员属性是被编译器给隐蔽了，因此是访问不到，但是确实被继承下去了
	cout << "size of son=" << sizeof(son) << endl;//16
}

int main()
{
	test01();
	system("pause");
	return 0;
}

输出：
size of son=16

继承中的构造和析构顺序

子类继承父类后，当创建子类对象，也会调用父类的构造函数。

#include<iostream>
using namespace std;

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

class son :public dad
{
public:
	son() 
	{
		cout << "son构造函数" << endl;
	}
	~son()
	{
		cout << "son析构函数" << endl;
	}
};

void test01()
{
	dad d;
}

void test02()
{
	cout << "继承中的构造和析构顺序如下：" << endl;
	//先构造父类，再构造子类，析构的顺序与构造顺序相反
	son s;
}

int main()
{
	test01();
	test02();
	system("pause");
	return 0;
}

输出：
dad构造函数
dad析构函数
继承中的构造和析构顺序如下：
dad构造函数
son构造函数
son析构函数
dad析构函数

总结：
继承中，先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反。

继承同名成员处理方式

访问子类同名成员，直接访问即可；
访问父类同名成员，需要加作用域。

#include<iostream>
using namespace std;

class dad
{
public:
	dad()
	{
		m_A = 100;
	}
	void func()
	{
		cout << "dad的func()调用" << endl;
	}
	void func(int a)
	{
		cout << "dad的func(int a)调用" << endl;
	}

	int m_A;
};

class son :public dad
{
public:
	son()
	{
		m_A = 200;
	}
	void func()
	{
		cout << "son的func()调用" << endl;
	}
	int m_A;
};

//同名成员属性处理
void test01()
{
	son s;
	cout << "son下m_A = " << s.m_A << endl;
	//如果通过子类对象访问到父类中同名成员，需要加作用域
	cout << "dad下m_A = " << s.dad::m_A << endl;
}

//同名成员函数处理
void test02()
{
	son s;
	s.func();//直接调用，调用的是子类中的同名成员
	s.dad::func();//调用到父类中的同名成员函数

	//如果子类中出现和父类同名的成员函数，子类的同名成员会隐藏掉父类中所有同名成员函数
	//如果想访问到父类中被隐藏的同名成员函数，需要加作用域
	s.dad::func(100);
}

int main()
{
	test01();
	test02();
	system("pause");
	return 0;
}

输出：
son下m_A = 200
dad下m_A = 100
son的func()调用
dad的func()调用
dad的func(int a)调用

总结：
1、子类对象可以直接访问子类中同名成员；
2、子类对象加作用域可以访问到父类同名成员；
3、当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域可以访问到父类中同名函数。

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

静态成员特点：
1、所有变量共享同一份数据；
2、编译阶段分配内存；
3、类内声明，类外初始化。

静态成员和非静态成员出现同名，处理方式一致：
访问子类同名成员，直接访问即可；
访问父类同名成员，需要加作用域。

#include<iostream>
using namespace std;

class dad
{
public:
	static void func()
	{
		cout << "dad的static void func()调用" << endl;
	}
	static void func(int a)
	{
		cout << "dad的static void func(int a)调用" << endl;
	}

	static int m_A;
};
int son::m_A = 100;

class son :public dad
{
public:
	static void func()
	{
		cout << "son的static void func()调用" << endl;
	}
	static int m_A;
};
int son::m_A = 200;

//同名成员属性处理
void test01()
{
	//通过对象访问
	cout << "通过对象访问：" << endl;
	son s;
	cout << "son下m_A = " << s.m_A << endl;
	//如果通过子类对象访问到父类中同名成员，需要加作用域
	cout << "dad下m_A = " << s.dad::m_A << endl;

	//通过类名访问
	cout << "通过类名访问：" << endl;
	cout << "son下m_A = " << son::m_A << endl;
	//第一个::代表通过类名方式访问 第二个::代表访问父类作用域下
	cout << "dad下m_A = " << son::dad::m_A << endl;
}

//同名成员函数处理
void test02()
{
	//通过对象访问
	cout << "通过对象访问：" << endl;
	son s;
	s.func();//直接调用，调用的是子类中的同名成员
	s.dad::func();//调用到父类中的同名成员函数

	//通过类名访问
	cout << "通过类名访问：" << endl;
	son::func();
	son::dad::func();
	//如果子类中出现和父类同名的静态成员函数，子类的同名成员会隐藏掉父类中所有同名成员函数
	//如果想访问到父类中被隐藏的同名成员函数，需要加作用域
	son::dad::func(100);
}

int main()
{
	test01();
	test02();
	system("pause");
	return 0;
}

总结：
同名静态成员处理方式和非静态处理方式一样，只不过有两种访问方式（通过对象和通过类名）。

多继承语法

c++允许一个类继承多个类

语法：class 子类 : 继承方式 父类1, 继承方式 父类2…

多继承可能会引发父类中有同名成员出现，需要加作用域区分

#include<iostream>
using namespace std;

class dad1
{
public:
	dad1()
	{
		m_A = 100;
	}
	int m_A;
};

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

class son :public dad1, public dad2
{
public:
	son()
	{
		m_C = 300;
		m_D = 400;
	}
	int m_C;
	int m_D;
};

void test01()
{
	son s;
	cout << "sizeof son = " << sizeof(s) << endl;
	//当父类在中出现同名成员，需要加作用域区分
	cout << "dad1::m_A = " << s.dad1::m_A << endl;
	cout << "dad2::m_A = " << s.dad2::m_A << endl;
}

int main()
{
	test01();
	system("pause");
	return 0;
}

菱形继承

概念：
两个派生类继承同一个基类，又有某个类同时继承这两个派生类。
这种继承称为菱形继承，或者砖石继承。

菱形继承问题：
1、产生二义性；
2、继承两份数据，资源浪费。

利用虚继承（加关键字virtual）可以解决菱形继承问题。

#include<iostream>
using namespace std;

class animal
{
public:
	int m_age;
};

//利用虚继承 解决菱形继承的问题
//继承之前 加上关键字virtual变为虚继承
//animal类称为虚基类
class sheep :virtual public animal{};

class tuo :virtual public animal{};

class sheeptuo :public sheep, public tuo{};

void test01()
{
	sheeptuo st;
	st.sheep::m_age = 18;
	st.tuo::m_age = 28;
	//当菱形继承，两个父类拥有相同数就，需要加上作用域区分
	cout << "st.sheep::m_age = " << st.sheep::m_age << endl;
	cout << "st.tuo::m_age = " << st.tuo::m_age << endl;
	cout << "st.m_age = " << st.m_age << endl;

	//这份数据我们知道，只有一份就可以，菱形继承导致数据有两份，造成资源浪费
}

int main()
{
	test01();
	system("pause");
	return 0;
}
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值