继承：基本语法/继承方式/继承中的对象模型/构造和析构顺序/同名成员处理/同名静态成员处理/多继承语法/菱形继承问题以及解决方法

原创 已于 2024-10-16 21:17:43 修改
· 232 阅读 · 1 ·
版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++

于 2024-10-16 21:15:37 首次发布

目录

1、基本语法

2、继承方式

3、继承中的对象模型

4、构造和析构顺序

5、同名成员处理

6、同名静态成员处理

7、多继承语法

8、菱形继承问题以及解决方法

1、基本语法

普通实现页面

继承好处：减少重复代码

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

子类也称为——派生类

父类也称为——基类

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

//继承

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


//继承实现页面
//公共页面类
class BasePage
{
public:
		void header()
	{
		cout << "首页、公开课、登录、注册...(公共头部)" << endl;
	}
	void footer()
	{
		cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
	}
	void left()
	{
		cout << "Java、Phthon、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 test01()
{
	cout << "Java下载页面视频如下" << endl;
	Java ja;
	ja.header();
	ja.footer();
	ja.left();
	ja.content();

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

	cout << "--------------------------------------------" << endl;
	cout << "C++下载页面视频如下" << endl;
	CPP c;
	c.header();
	c.footer();
	c.left();
	c.content();
}



int main()
{
	test01();

	system("pause");
	return 0;
}

2、继承方式

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

//继承方式

//公共继承
class  Base1
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;

};

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

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

//保护继承
class  Base2
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;

};

class Son2 :protected Base2
{
public:
	void func()
	{
		m_A = 10;//父类公共权限成员 到子类成员中变为保护权限
		m_B = 10;//父类保护权限成员 到子类成员中依然是保护权限
		//m_C = 10//父类私有权限成员 子类访问不到
	}
};
void test02()
{
	Son2 s1;
	//s1.m_A = 100;//继承方式是保护继承，类外访问不到
	//s1.m_B = 100;//到了Son2中 m_B是保护权限 类外访问不到
}
//私有继承
class  Base3
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;

};

class Son3 :private Base3
{
public:
	void func()
	{
		m_A = 10;//父类公共权限成员 到子类成员中变为私有权限
		m_B = 10;//父类保护权限成员 到子类成员中变为私有权限
		//m_C = 10//父类私有权限成员 子类访问不到
	}
};
void test03()
{
	Son3 s1;
	//s1.m_A = 100;//继承方式是私有继承，类外访问不到
	//s1.m_B = 100;//到了Son2中 m_B是保护权限 类外访问不到
}

int main()
{
	test01();
	test02();
	test03();

	system("pause");
	return 0;
}

3、继承中的对象模型

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

//继承方式

//公共继承
class Base
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};

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

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

int main()
{
	test01();

	system("pause");
	return 0;
}

这里增加一个使用工具：开发人员命令提示符

打开文件所在文件夹➡复制项目文件所在路径➡跳转盼复到F盘（命令：F：）

跳转文件路径：cd 具体路径下 

报告单个类的布局

cl /dl reportSingleClassLayout类名 文件名

4、构造和析构顺序

结论：

5、同名成员处理

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

//继承中同名成员处理
class Base
{
public:
	Base()
	{
		m_A = 100;
	}
	void func()
	{
		cout << "Base-func()调用" << endl;
	}
	void func(int a)
	{
		cout << "Base-func(int a)调用" << endl;
	}
	int m_A;

};

class Son :public Base
{
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 << "Base 下 m_A= " << s.Base::m_A << endl;//加作用域，通过子类对象访问父类中的同名成员
}
void test02()
{
	Son s;
	s.func();
	s.Base::func();

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

	system("pause");
	return 0;
}

6、同名静态成员处理

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

//继承中同名静态成员处理
class Base
{
public:

	static int m_A;

	static void func()
	{
		cout << "Base - static void func()" << endl;
	}

	static void func(int a)
	{
		cout << "Base - static void func(int a)" << endl;
	}
};

int Base::m_A=100;

class Son :public Base
{
public:
	static int m_A;

	static void func()
	{
		cout << "Son - static void func()" << endl;
	}
};
int Son::m_A = 200;

//同名静态成员属性
void test01()
{
	//1、通过对象访问数据
	Son s;
	cout << "通过对象访问：" << endl;
	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;
	//第一个::代表通过类名方式访问   第二个::代表父类作用域下
	cout << "Base 下 m_A=  " << Son::Base::m_A << endl;
}
//同名静态成员函数
void test02()
{
	//1、通过对象访问数据
	cout << "通过对象访问：" << endl;
	Son s;
	s.func();
	s.Base::func();

	//2、通过类名访问
	cout << "通过类名访问：" << endl;
	Son::func();
	Son::Base::func();

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

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

7、多继承语法

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

//多继承语法
class Base1
{
public:
	Base1()
	{
		m_A = 100;
	}
	int m_A;
};

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

//子类  需要继承Base1和Base2
//语法：  class  子类 ： 继承方式  父类1，继承方式 父类2 ...
class Son :public Base1, public Base2
{
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 << "Base1 下 m_A=" << s.Base1::m_A << endl;
	cout << "Base2 下 m_A=" << s.Base2::m_A << endl;
}

int main()
{
	test01();

	system("pause");
	return 0;
}

8、菱形继承问题以及解决方法

虚拟前：

虚拟后：（虚基类指针）

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

//动物类
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、付费专栏及课程。

余额充值