C++核心编程3

最新推荐文章于 2024-06-12 20:44:27 发布

->yjy

最新推荐文章于 2024-06-12 20:44:27 发布

阅读量27

点赞数

分类专栏： cpp 文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/2301_79602614/article/details/134451444

版权

cpp 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

继承

继承的基本语法

好比做网页有些是直接继承父级的也就是公共用的底部，甚至公共的左侧列表，只有中心内容不同

普通实现：


Java 
class Java
{
public:
	void header()
	{
		cout << "首页、公开课、登录、注册...(公共头部)"<<endl;

	}
	void footer()
	{
		cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
	}
	void left()
	{
		cout << "Java、Python、C++...(公共分类列表)" << endl;
	}
	void content()
	{
		cout << "Java学科视频" << endl;
	}

};

class Python
{
public:
	void header()
	{
		cout << "首页、公开课、登录、注册...(公共头部)" << endl;

	}
	void footer()
	{
		cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
	}
	void left()
	{
		cout << "Java、Python、C++...(公共分类列表)" << endl;
	}
	void content()
	{
		cout << "Python学科视频" << endl;
	}

};
class Cpp
{
public:
	void header()
	{
		cout << "首页、公开课、登录、注册...(公共头部)" << endl;

	}
	void footer()
	{
		cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
	}
	void left()
	{
		cout << "Java、Python、C++...(公共分类列表)" << endl;
	}
	void content()
	{
		cout << "Cpp学科视频" << endl;
	}

};

继承实现：

//继承实现页面
//公共页面
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;
	}
};


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();
}
int main()
{
	test01();

	return 0;
}
//继承的好处：减少重复的代码
//语法：class 子类 ：继承方式 父类
//子类也称为派生类  父类也称为基类

继承方式

公共继承

保护继承

私有继承

继承中的对象模型

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

#include<iostream>
using namespace std;
//继承中的对象模型
//利用开发人员命令提示工具查看对象模型
//跳转盘符 F：
//跳转文件路径 cd 具体路径下
//查看命名
//c1/d1 reportSingleClassLayout类名 文件名
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 << "size of Son = " << sizeof(Son) << endl;//16

}
int main()
{


	return 0;
}

继承中构造和析构顺序

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

问题：父类和子类的构造和析构函数顺序？

class Base
{
public:
	Base()
	{
		cout << "Base构造函数！" << endl;
	}
	~Base()
	{
		cout << "Base析构函数！" << endl;
	}
};
class Son :public Base
{
public:
	Son()
	{
		cout << "Son构造函数！" << endl;
	}
	~Son()
	{
		cout << "Son析构函数！" << endl;
	}
};
void test01()
{
	//Base b;
	Son s;
}
int main()
{

	test01();
	return 0;
}
//Base构造函数！
//Son构造函数！
//Son析构函数！
//Base析构函数！
//先构造父类 再构造子类 但是析构的顺序与构造的顺序相反

继承同名成员处理方式

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

访问子类同名函数，直接访问即可

访问父类同名函数，需要加作用域

class Base
{
public:
	Base()
	{
		m_A = 100;
	}
	void func()
	{
		cout << "Base - func()调用" << endl;
	}
//如果子类中出现和父类同名的成员函数，子类的同名成员会隐藏掉父类中所有同名成员函数
	//加作用域
	void func(int n)
	{
		cout << "Base - func()函数重载调用" << 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 << "m_A=" <<s.m_A<< endl;
	cout << "m_A=" <<s.Base::m_A<< endl;
}
//同名函数的处理

void test02()
{
	Son s1;
	s1.func();//直接调用 调用的是子类中的同名成员
	s1.Base::func();
	s1.Base::func(100);

}
int main()
{

	test01();
	test02();
	return 0;
}

继承同名静态成员的处理方法

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

静态成员和非静态成员出现同名，处理方式一致

访问子类同名函数，直接访问即可

访问父类同名函数，需要加作用域

class Base
{
public:
	
	static void func()
	{
		cout << "Base - func()调用" << endl;
	}
	static void func(int n)
	{
		cout << "Base - func()函数重载调用" << endl;
	}
	static int m_A;
};
int Base::m_A = 100;
class Son :public Base
{
public:
	
	static void func()
	{
		cout << "Son - func()调用" << endl;
	}
	static int m_A;
};
int Son::m_A = 200;
//同名成员属性的处理
void test01()
{//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;
	//第一个：：表示用类名方式 第二个：：表示在作用域下
	cout << "Base下m_A = " << Son::Base::m_A << endl;
}
//同名函数的处理

void test02()
{
	//通过对象访问
	Son s1;
	s1.func();//直接调用 调用的是子类中的同名成员
	s1.Base::func();
	s1.Base::func(100);
	//通过类名访问
	Son::func();
	Son::Base::func();
	Son::Base::func(100);

}
int main()
{

	test01();
	test02();
	return 0;
}

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

多继承语法

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

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

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

c++实际开发中不建议用多继承

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

class Base2
{
public:
	Base2()
	{
		m_B = 100;
	}
	int m_B;
};

//子类
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 << "m_A=" << s.m_A << endl;
	//如果出现同名直接加作用域就可以了
}
int main()
{
	test01();
	return 0;
}

菱形继承

菱形继承的概念：

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

又有某个类同时继承这两个派生类

这种继承被称之为菱形继承或者钻石继承

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;
	st.m_Age = 99;
	//加作用域加以区分
	//菱形继承导致了数据有两份导致了资源的浪费
}
int main()
{
	test01();
	return 0;
}

总结：菱形继承带来的主要问题是子类继承两份相同的数据，导致资源浪费以及毫无意义

利用虚继承可以解决继承问题