上传文件至 '继承1'

继承1/1、继承的基本语法.cpp

@@ -0,0 +1,191 @@
+//4.6     继承
+
+//继承是面向对象三大特征之一
+//有些类与类之间存在特殊的关系，例如：
+
+//🐱  🐕 都是  动物
+
+//我们发现  定义这些类时  下级别的成员除了拥有上一级的共性  还有自己的特性
+
+//这个时候我们就可以考虑利用继承的技术  减少重复代码
+
+
+//4.6.1    继承的基本语法
+
+//例如我们看到很多网站中，都有公共的头部，公共的底部，甚至公共的左侧列表  只有中心内容不同
+//接下来我们分别利用普通写法和继承写法来实现网页中的内容，看一下继承存在的意义和好处
+
+
+
+
+#include <iostream>
+
+
+
+
+//普通实现
+
+//Java页面
+//class Java
+//{
+//public:
+//	void header()
+//	{
+//		std::cout << "首页、公开课、登录、注册...(公共头部)" << std::endl;
+//	}
+//	void footer()
+//	{
+//		std::cout << "帮助中心、交流合作、站内地图...（公共底部）" << std::endl;
+//	}
+//	void left()
+//	{
+//		std::cout << "Java、Python、C++、...(公共分类列表)" << std::endl;
+//	}
+//	void content()
+//	{
+//		std::cout << "Java学习视频" << std::endl;
+//	}
+//};
+
+//Python页面
+//class Python
+//{
+//public:
+//	void header()
+//	{
+//		std::cout << "首页、公开课、登录、注册...(公共头部)" << std::endl;
+//	}
+//	void footer()
+//	{
+//		std::cout << "帮助中心、交流合作、站内地图...（公共底部）" << std::endl;
+//	}
+//	void left()
+//	{
+//		std::cout << "Java、Python、C++、...(公共分类列表)" << std::endl;
+//	}
+//	void content()
+//	{
+//		std::cout << "Python学习视频" << std::endl;
+//	}
+//};
+
+
+//C++页面
+//class Cpp
+//{
+//public:
+//	void header()
+//	{
+//		std::cout << "首页、公开课、登录、注册...(公共头部)" << std::endl;
+//	}
+//	void footer()
+//	{
+//		std::cout << "帮助中心、交流合作、站内地图...（公共底部）" << std::endl;
+//	}
+//	void left()
+//	{
+//		std::cout << "Java、Python、C++、...(公共分类列表)" << std::endl;
+//	}
+//	void content()
+//	{
+//		std::cout << "C++学习视频" << std::endl;
+//	}
+//};
+
+
+//继承实现
+class BasePage
+{
+public:
+	void header()
+	{
+		std::cout << "首页、公开课、登录、注册...(公共头部)" << std::endl;
+	}
+	void footer()
+	{
+		std::cout << "帮助中心、交流合作、站内地图...（公共底部）" << std::endl;
+	}
+	void left()
+	{
+		std::cout << "Java、Python、C++、...(公共分类列表)" << std::endl;
+	}
+
+};
+
+//继承的好处:减少重复代码
+//语法：
+//class 子类 : 继承方式
+//{
+//	父类
+//};
+
+//子类也 称为 派生类
+//父类也 称为 基 类  
+
+//Java页面
+class Java :public BasePage
+{
+public:
+	void content()
+	{
+		std::cout << "Java学习视频" << std::endl;
+	}
+};
+//Python页面
+class Python :public BasePage
+{
+public:
+	void content()
+	{
+		std::cout << "Python学习视频" << std::endl;
+	}
+};
+//C++页面
+class Cpp :public BasePage
+{
+public:
+	void content()
+	{
+		std::cout << "C++学习视频" << std::endl;
+	}
+};
+
+
+
+void test01()
+{
+	std::cout << "Java下载视频页面如下：" << std::endl;
+	Java ja;
+	ja.header();
+	ja.footer();
+	ja.left();
+	ja.content();
+
+	std::cout << "--------------------------------" << std::endl;
+	
+	std::cout << "Python下载视频页面如下：" << std::endl;
+	Python py;
+	py.header();
+	py.footer();
+	py.left();
+	py.content();
+
+	std::cout << "--------------------------------" << std::endl;
+
+	std::cout << "C++下载视频页面如下：" << std::endl;
+	Cpp cpp;
+	cpp.header();
+	cpp.footer();
+	cpp.left();
+	cpp.content();
+}
+
+int main()
+{
+	test01();
+
+	system("pause");
+
+	return 0;
+}
+

继承1/2、继承方式.cpp

@@ -0,0 +1,129 @@
+//4.6.2   继承方式
+
+//继承的语法:class 子类 : 继承方式  父类
+
+//继承方式一共有三种:
+
+//?公共继承
+
+//?保护继承
+
+//?私有继承
+
+
+
+
+
+
+#include <iostream>
+
+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_A = 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 = 100;         //父类公共到子类中变成保护权限
+		m_B = 100;         //父类保护到子类中变成保护权限
+		//m_C = 100;       //子类访问不到
+	}
+};
+
+void test02()
+{
+	Son2 s1;
+	//s1.m_A = 1000;         //在Son2中  m_A变为保护权限  因此类外访问不到
+	//s1.m_B = 1000;         //在Son2中  m_A变为保护权限  因此类外访问不到
+}
+
+class Base3
+{
+public:
+	int m_A;
+protected:
+	int m_B;
+private:
+	int m_C;
+
+};
+
+class Son3 :private Base3
+{
+public:
+	void func()
+	{
+		m_A = 100;        //父类中公共成员，子类变为私有成员
+		m_B = 100;        //父类中保护乘员，子类变为私有成员
+		//m_C = 100;      //父类中私有成员，子类访问不到
+	}
+};
+
+class Grandson :public Son3
+{
+public:
+	void func()
+	{
+		//m_A = 1000;       //到了Son3中  m_A变为私有  即使是儿子  也是访问不到
+		//m_B = 1000;       //到了Son3中  m_B变为私有  即使是儿子  也是访问不到
+	}
+};
+
+void test03()
+{
+	Son3 s1;
+	//s1.m_A = 1000;       //变为私有成员  类外访问不到
+	//s1.m_C = 1000;       //变为私有成员  类外访问不到
+}
+
+int main()
+{
+
+
+
+	system("pause");
+
+	return 0;
+}
+
+

继承1/3、继承中的对象模型.cpp

@@ -0,0 +1,52 @@
+//4.6.3    继承中的对象模型
+
+//问题 ：从父亲继承来的成员，哪些属于子类对象中?
+
+
+
+#include <iostream>
+
+class Base
+{
+public:
+	int m_A;
+protected:
+	int m_B;
+private:
+	int m_C;
+};
+
+class Son :public Base
+{
+public:
+	int m_D;
+};
+
+
+//利用开发人员命令提示工具查看对象模型
+//跳转盘符  D:  文件路径所在硬盘
+//跳转文件路径  cd 具体路径下
+//查看命名
+//c1 /d1 reportSingleClassLayout类名 文件名
+
+void test01()
+{
+	//16
+	//父类中所有非静态成员属性都会被子类继承下去
+	//父类中私有成员属性 是被编译器隐藏了 因此是访问不到的  但确实被继承了下去
+	std::cout << "size of Son = " << sizeof(Son) << std::endl;
+}
+
+int main()
+{
+	test01();
+
+	system("pause");
+
+
+	return 0;
+}
+
+
+
+//父类中私有成员也是被子类继承下去了，只是由编译器隐藏后访问不到

继承1/4、继承中构造和析构顺序.cpp

@@ -0,0 +1,62 @@
+//4.6.4   继承中构造和析构顺序
+
+//子类继承父类后，当创建子类对象，也会调用父类的构造函数
+
+//问题:父类和子类的构造和析构顺序是谁先谁后？
+
+
+
+#include <iostream>
+
+class Base
+{
+public:
+	Base()
+	{
+		std::cout << "Base的构造函数" << std::endl;
+	}
+
+	~Base()
+	{
+		std::cout << "Base的析构函数" << std::endl;
+	}
+};
+
+class Son :public Base
+{
+public:
+	Son()
+	{
+		std::cout << "Son的构造函数" << std::endl;
+	}
+
+	~Son()
+	{
+		std::cout << "Son的析构函数" << std::endl;
+	}
+};
+
+
+void test01()
+{
+	//Base b;
+
+	//继承中的构造和析构顺序如下:
+	//先构造父亲，再构造子类，析构的顺序和构造的顺序相反
+	Son s;
+}
+
+int main()
+{
+	test01();
+
+
+	system("psuse");
+
+	return 0;
+}
+
+
+
+
+//继承中  先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反