//继承：下级别的成员除了有上一级的共性，还有自己的特性！！！！！
#include<iostream>
using namespace std;
#include<string>
//普通实现页面 -----过多重复的代码了！！！！！
// //JAVA的页面
//class JAVA
//{
//public:
// void header()
// { cout << "公共 头部 信息：。。。。。" << endl; }
// void footer()
// { cout << "公共 底部 信息：。。。。。" << endl; }
// void left()
// { cout << "公共 左侧 信息：。。。。。" << endl; }
//
// void cnetent()
// { cout << "JAVA 包含的内容：。。。。。" << endl; }
//};
//
// //Python的页面
//class Python
//{
//public:
// void header()
// { cout << "公共 头部 信息：。。。。。" << endl; }
// void footer()
// { cout << "公共 底部 信息：。。。。。" << endl; }
// void left()
// { cout << "公共 左侧 信息：。。。。。" << endl; }
//
// void cnetent()
// { cout << "Python 包含的内容：。。。。。" << endl; }
//};
//
// //C的页面
//class C
//{
//public:
// void header()
// { cout << "公共 头部 信息：。。。。。" << endl; }
// void footer()
// { cout << "公共 底部 信息：。。。。。" << endl; }
// void left()
// { cout << "公共 左侧 信息：。。。。。" << endl; }
//
// void cnetent()
// { cout << "C 包含的内容：。。。。。" << endl; }
//};
//void test01()
//{
// cout << "JAVA 网页页面构成如下：" << endl;
// JAVA ja;
// ja.header(); //调用类当中的函数记得 加“（）”！！！！！
// ja.footer();
// ja.left();
// ja.cnetent();
//
// cout << "------------------------------------" << endl;//分割作用
//
// cout << "Python 网页页面构成如下：" << endl;
// Python py;
// py.header();
// py.footer();
// py.left();
// py.cnetent();
//
// cout << "------------------------------------" << endl;//分割作用
//
// cout << "C 网页页面构成如下：" << endl;
// Python c;
// c.header();
// c.footer();
// c.left();
// c.cnetent();
//}
//int main()
//{
// test01();
// return 0;
//}
//继承实现页面 -----把有复制粘贴共同的代码抽离出来
//class BasePage //公共的部分的类
//{
//public:
// void header()
// { cout << "公共 头部 信息：。。。。。" << endl; }
// void footer()
// { cout << "公共 底部 信息：。。。。。" << endl; }
// void left()
// { cout << "公共 左侧 信息：。。。。。" << endl; }
//};
// //JAVA的页面
//class JAVA : public BasePage //”class 类名 ： public 需要被继承的类名 {}；“ 即完成了对类的继承！！！！！！！！！！
//{
//public:
// void cnetent()
// {
// cout << "JAVA 包含的内容：。。。。。" << endl;
// }
//};
// //Python的页面
//class Python : public BasePage
//{
//public:
// void cnetent()
// {
// cout << "Python 包含的内容：。。。。。" << endl;
// }
//};
// //C的页面
//class C : public BasePage
//{
//public:
// void cnetent()
// {
// cout << "C 包含的内容：。。。。。" << endl;
// }
//};
//void test01()
//{
// cout << "JAVA 网页页面构成如下：" << endl;
// JAVA ja;
// ja.header(); //调用类当中的函数记得 加“（）”！！！！！
// ja.footer();
// ja.left();
// ja.cnetent();
//
// cout << "------------------------------------" << endl;//分割作用
//
// cout << "Python 网页页面构成如下：" << endl;
// Python py;
// py.header();
// py.footer();
// py.left();
// py.cnetent();
//
// cout << "------------------------------------" << endl;//分割作用
//
// cout << "C 网页页面构成如下：" << endl;
// Python c;
// c.header();
// c.footer();
// c.left();
// c.cnetent();
//}
//int main()
//{
// test01();
// return 0;
//}
//继承好处：减少重复的代码！！！！！ 语法：“class 子类 ： 继承方式 父类（ {}； ”
//子类 也叫为 -----派生类
//父类 也叫为 -----基类
//继承方式:！！！！！父类当中私有的（private)一般子类当中是不能访问的！！！！！
//公共继承：父类当中 public与protected 仍然是 在子类当中继承 public与protected
//保护继承：父类当中public与protected 在子类当中继承都变成了 protected
//私有继承：父类当中public与protected 在子类当中继承都变成了 private
//class Base //父类
//{
//public:
// int m_A;
//protected:
// int m_B;
//private:
// int m_C;
//};
////1、公共继承
//class Son1 :public Base
//{
//public:
// void func()
// {
// m_A = 10;//父类 当中 公共权限 成员可以访问！ 依然是公共权限！！！！！
// m_B = 10;//父类 当中 保护权限 成员可以访问！ 依然是保护权限！！！！！
// //m_C = 10; //报错 父类当中私有权限成员 子类当中访问不到！
// }
//};
//void test01()
//{
// Son1 s1;
// s1.m_A = 100;//在子类当中依然是 公共权限 ！特点：类外 类内都可以访问！！！！！
// //s1.m_B = 100; 报错：在子类当中依然是保护权限，保护权限在类内可以访问 但是在类外是不允许访问的！！！！！
//}
////2、保护继承
//class Son2 :protected Base
//{
//public:
// void func()
// {
// m_A = 100; // 父类 当中 ！公共权限！在 ！保护继承！ 后再！子类！当中变成了 ！保护权限！！！！！
// m_B = 100;//父类当 保护权限 仍然是保护权限在子类当中！！！！！！
// //m_C = 100; //报错 父类当中私有权限成员 子类当中访问不到！
// }
//};
//void test02()
//{
// Son2 s2;
// //s2.m_A = 100;//发生错误 保护权限不能在类外访问！
//}
////3、私有继承
//class Son3:private Base
//{
//public:
// void func()
// {
// m_A = 100;//父类当中公共与保护的权限都变成了私有权限！！！！！
// m_B = 100;
// //m_C = 100; 报错 父类当中私有权限成员 子类当中访问不到
// }
//};
//void test03()
//{
// Son3 s3;
// //s3.m_A = 100; 报错 私有权限不能在类外直接访问！！！！！
//}
//
//int main()
//{
// return 0;
//}
//继承当中的对象模型
//class Base
//{
//public:
// int m_A;
//protected:
// int m_B;
//private:
// int m_C;//私有的属性是被编译器继承时隐藏 了是访问不到 不是没有！！！！！
//};
//class Son :public Base
//{
//public:
// int m_D;
//};
//void test01()
//{
// cout << "sizeof Son: " << sizeof(Son) << endl;//16 m_A/m_B/m_C/m_D 4个int ！父类当中所以 非静态的成员属性都会被子类继承下去！！！！！
//}
//int main()
//{
// test01();
// return 0;
//}
//继承中的 构造 和 析构的 顺序
//class Base //父类
//{
//public:
// Base()
// {
// cout << "父类当中的 构造函数！" << endl;
// }
// ~Base()
// {
// cout << "父类当中的 析构函数！" << endl;
// }
//};
//class Son :public Base
//{
//public:
// Son()
// {
// cout << "子类当中的 构造函数！" << endl;
// }
// ~Son()
// {
// cout << "子类当中的 析构函数！" << endl;
// }
//};
//void test01() //全局函数创建在 栈上！！！！！
//{
// //Base b;
// Son p;//！！！！！！！！！！先父类构造 -》子类构造-》子类析构-》父类析构！！！！！！！！！！
//}
//int main()
//{
// test01();
// return 0;
//}
//继承当中 同名 的 成员 处理方法:（通过子类对象）访问 子类 当中同名成员 ，直接访问即可； 访问 父类 当中同名成员 ，需要加作用域！！！！！
//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 = 5;
// }
//
// void func()
// {
// cout << "Son-func的成员函数调用！" << endl;
// }
//
// int m_A;
//};
//void test01() //----- 同名的 成员属性 之间的应用
//{
// Son s;
// cout << s.m_A << endl;//打印的是 子类的 同名数据！！！！！
// cout <<s.Base::m_A << endl;//通过子类对象访问父类当中的同名成员属性 需要加上父类当中的作用域才能进行访问！！！！！
//}
//void test02() //----- 同名的 成员函数 之间的应用
//{
// Son s;
// s.func();//直接调用的是 子类当中的成员函数！
// s.Base::func();//通过子类对象访问父类当中的同名成员函数 需要加上父类当中的作用域才能进行访问！！！！！
//
// s.Base::func(5);
// //子类当中出现了与父类同名的成员函数，子类的同名函数会隐藏掉父类当中的所有同名函数 所以访问父类的同名成员函数一定要加 父类的作用域！！！！！
//
//}
//int main()
//{
// //test01();
// test02();
// return 0;
//}
//继承 同名 静态成员 的处理:（通过子类对象）访问 子类 当中同名成员 ，直接访问即可； 访问 父类 当中同名成员 ，需要加作用域！！！！！
//class Base
//{
//public:
// static void func()
// {
// cout << "Base - static void func()的调用！" << endl;
// }
// static int m_A; //静态成员 ：编译器分配内存，所以对象共享同一份数据域，类内声明，类外初始化！
//};
//int Base::m_A = 100;
//
//class Son:public Base
//{
//public:
// static void func()
// {
// cout << "Son- static void func()的调用！" << endl;
// }
// static int m_A;
//};
//int Son::m_A = 5;
//
////同名的静态成员属性
//void test01()
//{
// //1、通过对象访问数据（静态成员）
// Son s;
// cout <<"通过对象访问： "<<s.m_A << endl;//与非静态相同规则
// cout <<"通过对象访问： " << s.Base::m_A << endl;
//
// //2、通过类名访问数据
// cout << "通过类名访问 ：" << Son::m_A << endl;
// cout << "通过类名访问 ：" << Son::Base::m_A << endl;//子类当中通过类名的方式访问父类作用域下的m_A！！！！！
//}
////同名的静态成员函数
//void test02()
//{
// //1、通过对象访问！
// Son s;
// s.func();
// s.Base::func();
//
// //2、通过类名访问
// Son::func();
// Son::Base::func();
//}
//int main()
//{
// //test01();
// test02();
// return 0;
//}
//多继承语法：class 子类 ：继承方式 父类1 ，继承方式 父类2,...
//多继承可能会引发 父类 当中有同名成员出现，需要加作用域区分！！！！！（不建议使用多继承！）
//class Base1
//{
//public:
// Base1()
// {
// m_A = 100;
// }
// int m_A;
//};
//class Base2
//{
//public:
// Base2()
// {
// m_A = 50;
// }
// int m_A;
//};
// //子类 需要继承Base1和Base2
//class Son :public Base1, public Base2
//{
//public:
// Son()
// {
// m_C = 90;
// m_D = 80;
// }
// int m_C;
// int m_D;
//};
//void test01()
//{
// Son s;
// cout << "Son sizeof = " << sizeof(Son) << endl;//16
//
// cout << "输出父类当中的 m_A： " << s.Base1::m_A << endl;//访问同名的成员 需要加 作用域！！！！！
// cout << "输出父类当中的 m_A： " << s.Base2::m_A << endl;
//}
//int main()
//{
// test01();
// return 0;
//}
//菱形继承！！！！！：有 两个子类1/2 -继承同一个父类 -又有一个子类3同时继承子类1/2-----也叫菱形继承/钻石继承！！！！！问题看图片！
//动物类(父类）class Animal
{
public:
int m_A;
};
//利用 “虚继承”可以解决菱形继承的 存储浪费问题！！！！！ 在存储方式前面加上：virtual！！！！！！！！！！这样Animal 类就会变成：虚基类！//羊类（子类1）class Sheep :virtual public Animal
{
public:};
//驼类（子类2）
class Tuo :virtual public Animal
{
public:};
//羊驼类（子类3）
class SheepTuo :public Sheep, public Tuo //会导致羊驼类 继承了 两份m_A是数据！
{
public:};
void test01()
{
//SheepTuo st;
//st.Tuo::m_A = 100;//如不包括作用域会使得编译器不知道 m_A是哪的！
//st.Sheep::m_A = 90;
////出现菱形继承的时，两个父类拥有相同的数据，需要加以作用域区分！
//cout << "st.Tuo::m_A=; " << st.Tuo::m_A << endl;
//cout << "st.Sheep::m_A= " << st.Sheep::m_A << endl;
//但是在 羊驼当中 m_A只要有一份就可以了，菱形继承导致数据有两份 会造成存储的浪费！！！！！
SheepTuo st;
st.Tuo::m_A = 100;
st.Sheep::m_A = 90;
cout << "st.Tuo::m_A=; " << st.Tuo::m_A << endl;//90
cout << "st.Sheep::m_A= " << st.Sheep::m_A << endl;//90
//用上 虚继承之后 输出都变成90了！因为当是 虚继承之后 m_A数据只有一份了 当 m_A=90会覆盖m_A=100！！！！！
cout << st.m_A << endl;//因为只有一份数据了 所以不需要加作用域了！！！！！
}
int main()
{
test01();
return 0;
}
