#include<iostream>
using namespace std;
#include <string>
//模拟网页
class BasePage {
public:
	void header() {
		cout << "公共头部" << endl;
	}
	void footer() {
		cout << "公共底部" << endl;
	}
};
//Java页面
class Java :public BasePage {
public:
	void content() {
		cout << "java学科内容" << endl;
	}
};
class Python :public BasePage {
public:
	void content() {
		cout << "python学科内容" << endl;
	}
};
void test01() {
	cout << "java内容如下：" << endl;
	Java ja;
	ja.header();
	ja.footer();
	ja.content();


	cout << "python内容如下：" << endl;
	Python py;
	py.header();
	py.footer();
	py.content();
}
int main() {
	test01();
	system("pause");
	return 0;
}

继承方式

共有三种：

公共继承

保护继承

私有继承

父类中所有非静态成员属性都会被子类继承

父类中私有成员属性是被编译器隐藏了，因此访问不到，但是确实继承了

查看类：

利用开发人员命令提示工具查看工具

跳转盘符 F：

跳转文件路径 cd 具体路径

查看类cl /d1 reportSingleClassLayout类名文件名

cl /d1 reportSingleClassLayoutJava 赋值运算符重载.cpp

继承中构造和析构顺序

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

先构造父类，再构造子类，

先析构子类，再析构父类

继承同名成员处理方式：

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

son.func(); //直接调用，调用的是子类中的同名函数
son.Base::func();//加作用域调用父类中的同名函数

如果子类中出现和父类同名的函数，子类中同名成员函数会隐藏父类中所有的同名成员函数，不能访问，加上作用域则可以访问。

#include<iostream>
using namespace std;
#include <string>
class Base {
public:
	Base() {
		m_a = 100;
	}
	int m_a;
	void func() {
		cout << "父类func" << endl;
	}
};
class Son :public Base {
public:
	Son() {
		m_a = 200;
	}
	void func() {
		cout << "子类func" << endl;
	}
	int m_a;
};
//同名成员属性处理
void test01() {
	Son son;
	cout << "son" << son.m_a << endl;
	cout << "base" << son.Base::m_a << endl;  //需要加作用域
}
//同名成员函数处理
void test02() {
	Son son;
	son.func();  //直接调用，调用的是子类中的同名函数
	son.Base::func();//加作用域 调用父类中的同名函数
}
int main() {
	test01();
	test02();
	system("pause");
	return 0;
}

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

同非静态成员，但多一种通过类名访问的方式

Son::Base::m_a

Son::Base::func();

访问子类中的同名成员，直接访问

访问父类中的同名成员，加作用域

如果子类中出现和父类同名的函数，子类中同名成员函数会隐藏父类中所有的同名成员函数，不能访问，加上作用域则可以访问

#include<iostream>
using namespace std;
#include <string>
class Base {
public:
	static int m_a;//类内声明，类外初始化
	static void func() {
		cout << "base static func" << endl;
	}
	
};
int Base::m_a = 100;
class Son :public Base {
public:
	static int m_a;
	static void func() {
		cout << "son static func" << endl;
	}
};
int Son::m_a = 200;
//同名成员属性处理
void test01() {
	//通过对象访问
	cout << "通过对象访问" << endl;
	Son son;
	cout << "son" << son.m_a << endl;
	cout << "base" << son.Base::m_a << endl;  //需要加作用域
	//通过类名访问
	cout << "son" << Son::m_a << endl;
	//第一个::表示通过类名访问，第二个::表示访问父类作用域下
	cout << "base" << Son::Base::m_a << endl;
}
//同名成员函数处理
void test02() {
	//通过对象
	Son s;
	s.func();
	s.Base::func();
	//通过类名
	Son::func();
	Son::Base::func();
}
int main() {
	test01();
	test02();
	system("pause");
	return 0;
}

多继承语法

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

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

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

不建议使用多继承

菱形继承

两个派生类继承同一个基类，又有某个类同时继承着两个派生类，这种继承称为菱形继承或者钻石继承

菱形继承问题：

羊和驼都继承了动物的数据，羊驼在进行继承时会产生二义性

羊驼继承了两份动物的数据，重复 ,导致资源浪费，使用virtual关键字

继承指针而不是数据，通过指针偏移量找到数据

#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 YT :public Sheep,public Tuo {

};
void test01() {
	YT yt;
	// 菱形继承需要加作用域区分相同数据（不使用虚继承时）
	yt.Sheep::m_age = 19;
	yt.Tuo::m_age = 20;
	cout << yt.Sheep::m_age << endl;
	cout << yt.Tuo::m_age << endl;
	// 相同数据只需要一份 虚继承
	cout << yt.m_age << endl;

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