继承-- 基本语法/继承方式/继承中的对象模型/继承中的构造和析构顺序/继承中同名成员（属性和函数）处理/同名静态成员的处理方式/多继承语法/菱形继承（钻石继承）以及解决方法

基本语法

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

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

子类    也成为    派生类

父类    也称为    基类

#define _CRT_SECURE_NO_WARNINGS 
#include<iostream>
using namespace std;

//=============================================
//不适用继承

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



//========================================================================
// 使用继承技术

class Base
{
public:
	void head()
	{
		cout << "首页，公开课，登录，注册......（公共头部）" << endl;
	}
	void foot()
	{
		cout << "帮助中心，交流合作，站内地图....（公共底部）" << endl;
	}

	void left()
	{
		cout << "java,python,C++....(公共分类列表)" << endl;
	}
};

class Java : public Base
{
public:
	void content()
	{
		cout << "Java学科视频" << endl;
	}
};

class Python : public Base
{
public:
	void content()
	{
		cout << "Python学科视频" << endl;
	}
};

class Cpp : public Base
{
public:
	void content()
	{
		cout << "Cpp学科视频" << endl;
	}
};
void test01()
{
	// java页面展示
	Java java;
	java.head();
	java.left();
	java.foot();
	java.content();
	cout << "===============================" << endl;

	// Python页面展示
	Python python;
	python.head();
	python.left();
	python.foot();
	python.content();
	cout << "===============================" << endl;

	// C++页面展示
	Cpp cpp;
	cpp.head();
	cpp.left();
	cpp.foot();
	cpp.content();
	cout << "===============================" << endl;
}



int main()
{
	test01();

	system("pause");
	return 0;
}

继承方式

继承中的对象模型

继承中的构造和析构顺序

#define _CRT_SECURE_NO_WARNINGS 
#include<iostream>
using namespace std;

class Base
{
public:
	Base()
	{
		cout << "父类构造函数的调用！" << endl;
	}
	~Base()
	{
		cout << "父类析构函数的调用！" << endl;
	}
};
class Son : public Base
{
public:
	Son()
	{
		cout << "子类构造函数的调用" << endl;
	}
	~Son()
	{
		cout << "子类析构函数的调用" << endl;
	}
};
void test01()
{
	Son son;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

继承同名成员（属性和函数）处理

#define _CRT_SECURE_NO_WARNINGS 
#include<iostream>
using namespace std;
class Base
{
public:
	int a;
	Base()
	{
		a = 100;
	}
	void func()
	{
		cout << "Base类---func函数的调用" << endl;
	}
	void func(int a)
	{
		cout << "Base类---func(int a)函数的调用" << endl;
	}
};
class Son : public Base
{
public:
	int a;
	Son()
	{
		a = 200;
	}
	void func()
	{
		cout << "Son类---func函数的调用" << endl;
	}
};

//同名成员属性的处理
void test01()
{
	Son s;
	cout << s.a << endl; //输出子类中的同名成员
	cout << s.Base::a << endl;//输出父类中的同名成员
}

//同名成员函数的处理
void test02()
{
	Son s;
	s.func();
	s.Base::func();
	//如果子类中出现和父类同名的成员函数，子类的同名成员函数会隐藏掉父类中所有同名成员函数
	//s.func(10);

	s.Base::func(10);
}
int main()
{
	//test01();
	test02();
	system("pause");
	return 0;
}

同名静态成员的处理方式

静态成员函数比非静态多了一个通过类名访问，其它的和非静态一样。

#define _CRT_SECURE_NO_WARNINGS 
#include<iostream>
using namespace std;

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

class Base
{
public:
	// 静态成员三个特性
	// 编译阶段分配内存/所有对象共享同一份数据/类内声明类外初始化
	static int A;
	static void func()
	{
		cout << "Base --> func()" << endl;
	}
	static void func(int a)
	{
		cout << "Base --> func(int a)" << endl;
	}
};
int Base::A = 100;

class Son :public Base
{
public:
	static int A;
	static void func()
	{
		cout << "Son --> func()" << endl;
	}
};
int Son::A = 200;
// 1.同名静态成员属性
void test01()
{
	// 1.通过类名访问
	Son s;
	cout << "s --> A = " << s.A << endl;
	cout << "B --> A = " << s.Base::A << endl;

	// 2.通过类名访问
	cout << "s --> A = " << Son::A << endl;
	// 第一个::代表通过类名的方式访问，第二个::代表父类作用下
	cout << "B --> A = " << Son::Base::A << endl;
}

// 2.同名静态成员函数
void test02()
{
	Son s;
	// 1.通过对象的方式
	s.func();
	s.Base::func();

	// 2.通过类名的方式
	Son::func();
	Son::Base::func();

	// 如果子类出现了同名的静态成员函数，那么将会隐藏掉所有父类中同名
	// 的（包括重载的）函数
	// 如果想访问父类中被隐藏的成员函数，需要加作用域
	Son::Base::func(100);
}
int main()
{
	//test01();
	test02();
	system("pause");
	return 0;
}

多继承语法

#define _CRT_SECURE_NO_WARNINGS 
#include<iostream>
using namespace std;
// 多继承语法

class Base1
{
public:
	int a;
	Base1()
	{
		a = 100;
		b = 200;
	}
	int b;

};
class Base2
{
public:
	int a;
	int c;
	Base2()
	{
		a = 300;
		c = 400;
	}

};
class Son :public Base1, public Base2
{
public:
	int d;
	Son()
	{
		d = 600;
	}

};
void test01()
{
	Son s;
	//当父类中出现同名成员，需要加作用域加以区分
	cout << s.d << endl;
	cout << s.Base1::a << endl;
	cout << s.Base2::a << endl;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

菱形继承（钻石继承）以及解决方法

虚继承，利用指针与偏移量

#define _CRT_SECURE_NO_WARNINGS 
#include<iostream>
using namespace std;
class Animal // 虚基类
{
public:
	int age;
};
class Sheep:virtual public Animal {};//虚继承
class Tuo:virtual public Animal {};
class SheepTuo :public Sheep, public Tuo {};
void test01()
{
	SheepTuo s;
	
	//s.Animal::age 相当于 s.Sheep::Animal::age;
	//默认第一个子类
	//s.Animal::age = 100;
	s.Sheep::age = 10;
	s.Tuo::age = 18;

	cout << "s.Sheep::age =" << s.Sheep::age <<endl;
	cout << "s.Tuo::age = " << s.Tuo::age <<endl;
	cout << "s.Animal::age =" << s.Animal::age <<endl;

	// 这份数据我们知道，只要有一份就足够了，菱形继承导致数据有两份，资源浪费
	// 利用虚继承，可以解决菱形继承的问题
	// 在继承方式之前加上关键字 virtual 变为虚继承
	// 此时Animal类称为虚基类
	// 虚继承表示子类公用同一份数据了
}
int main()
{
	test01();
	system("pause");
	return 0;
}