提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档
前言
提示：这里可以添加本文要记录的大概内容：
5.1 继承的基本语法
定义这些类的时候，下级别的成员除了拥有上一级别的共性还有自己的特性，利用继承的技术，减少重复代码
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 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 test1()
{
cout<<"java下载视频页面如下："<<endl;
JAVA java;
java.header();
java.footer();
java.left();
java.content();
cout<<"```````````````"<<endl;
cout<<"java下载视频页面如下："<<endl;
Python python;
python.header();
python.footer();
python.left();
python.content();
}
继承的好处：减少重复代码
语法： class 子类：继承方式 父类
eg： class Python : public Basepage
子类 也称为 派生类
父类 也称为 基类
子类中的成员，包含两大部分：
一类是从父类继承过来的，一类是自己增加的成员，从父类继承过来的表现其共性，而新增的成员体现其个性
5.2 继承方式
继承方式包含三种：
1、公共继承
2、保护继承
3、私有继承
//公共继承
//父类
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_B=10； //父类中的保护权限成员 到子类中依然是保护权限
//m_C=10； //父类中的私有权限成员 子类访问不到
}
};
void test1()
{
Son1 s1;
s1.m_A=100; //公共权限类内类外都可以访问
//s1.m_B=100;//保护权限类外不能访问
}
//保护继承
//父类
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 test2()
{
Son2 s1;
//s1.m_A=100; //访问不到， Son2中m_A变为保护权限因为子类对象中是保护权限
//s1.m_B=100;// Son2中m_B变为保护权限因为子类对象中是保护权限
}
//私有继承
//父类
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; //父类中的私有成员 子类访问不到
}
};
void test3()
{
Son3 s1;
//s3.m_A=100; //访问不到， Son3中m_A变为私有权限因为子类对象中是私有权限
//s3.m_B=100;// Son2中m_B变为私有权限因为子类对象中是私有权限
}
class Grandson3 : public Son3
{
public:
void func()
{
//m_A=100;//到了Son3中m_A就变成了私有，即使是son3的儿子也访问不到
//m_B=100;
}
}
5.3 继承中的对象模型
父类中的私有成员也是被子类继承下去了，只是由编译器给隐藏后访问不到
//父类中所有的非静态成员属性都会被子类继承下去，都在子类里面
//父类中私有的成员属性是被编译器隐藏了，因此访问不到，但确实是被继承下去了
//继承中的对象模型
class Base
{
public：
int m_A;
protected:
int m_B;
private:
int m_C;
}；
class Son : public Base
{
public:
int m_D;
};
coid test1()
{
//父类中所有的非静态成员属性都会被子类继承下去，都在子类里面
//父类中私有的成员属性是被编译器隐藏了，因此访问不到，但确实是被继承下去了
cout<<"size of Son= "<<sizeof(Son)<<endl; //16
}
int main()
{
test1();
system()
}
查看工具：（利用开发人员命令提示工具查看对象模型）
跳转盘符 F：
跳转文件路径 cd 具体路径下
查看该路径下是否有这个文件命名（dir）
c1 /d1 reportSingleClassLayout类名 文件名
5.4 继承中构造和析构顺序
子类继承父类之后，当创建子类对象，也会调用父类的构造函数
那么父类和子类的构造和析构顺序是谁先谁后呢？
//继承中的构造和析构顺序如下：
//先构造父类，在构造子类，析构顺序与构造顺序相反
class Base
{
public:
Base()
{
cout<<"Base构造函数！"<<endl;
}
~Base()
{
cout<<"Base析构函数！"<<endl;
}
};
class Son : public Base
{
public:
Son()
{
cout<<"Base构造函数！"<<endl;
}
~Son()
{
cout<<"Base析构函数！"<<endl;
}
};
void test1()
{
//Base b; //输出Base的构造函数，Base的析构函数
Son s； // 输出 Base的构造函数，Son的构造函数，Son的析构函数，Base的析构函数
//继承中的构造和析构顺序如下：
//先构造父类，在构造子类，析构顺序与构造顺序相反
}
int main()
{
test1();
system("pause");
return 0;
}
5.5 继承同名成员处理方法
当子类与父类出现同名的成员，如何通过子类对象，访问到子类或父类中同名的数据？
- 访问子类同名成员 ，直接访问即可
- 访问父类同名成员，需要加作用域
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=200;
}
void func()
{
cout<<"Son -func()调用"<<endl;
}
int m_A;
};
//同名成员属性处理
void test1()
{
Son s；
cout<<"Son下的 m_A="<<s.m_A<<emdl; //直接打印，输出son下的200
//如果通过子类对象 访问到父类中同名成员，需要加作用域
cout<<"Base下的 m_A="<<s.Base::m_A<<emdl; //加了作用域，输出Base下的200
}
//同名成员函数处理
void test2()
{
Son s;
//直接调用 调用的是子类中的同名成员
s.func(); //Son -func()调用
s.Base::func(); //Base-func()调用
//如果子类中出现与父类同名的成员函数，子类的同名成员会隐藏掉父类中所有同名成员函数
//s.func(100); //❌，因为父类中的同名成员函数已经被隐藏了
//如果想访问到父类中被隐藏的同名成员函数，需要加作用域
s.Base::func(100);
}
int main()
{
test1();
system("pause");
return 0;
}
5.6 继承同名静态成员处理方式
- 静态成员变量（加static）的特点：
所有对象共享同一份数据
编译阶段就分配内存
类内声明，类外初始化 - 静态成员函数的特点：
只能访问静态成员变量，不能访问非静态成员变量
所有对象共享同一份函数实例
静态成员和非静态成员出现同名，处理方式一致
1、访问子类同名成员 直接访问即可
2、访问父类同名成员，需要加作用域
同名静态成员处理方式和非静态处理方式意义，只不过有两种访问方式（通过对象和通过类名）
class Base
{
public:
static int m_A;
static void func()
{
cout<<"Base-static void func()"<<endl;
}
};
int Base::m_A=100; //类外初始化
class Son: public Base
{
public:
static int m_A;
static void func()
{
cout<<"Son-static void func()"<<endl;
}
};
int Base::m_A=200; //类外初始化
//同名静态成员属性
void test1()
{
//1、通过对象访问
cout<<"通过对象访问 "<<endl;
Son s;
cout<<"Son 下m_A= "<<s.m_A<<endl; //200
cout<<"Base 下m_A= "<<s.Base::m_A<<endl; //100
//2、通过类名访问（因为所有成员共享同一份数据）
cout<<"通过类名访问 "<<endl;
cout<<"Son 下m_A= "<<Son::m_A<<endl; //200
//第一个：：代表通过类名方式访问，第二个：：代表访问父类作用域下
cout<<"Base 下m_A= "<<Son::Base::m_A<<endl; //200
}
//同名静态成员函数
void test2()
{
//1、通过对象访问
cout<<"通过对象访问 "<<endl;
Son s;
s.func(); //Base-static void func()
s.Base::func();
//2、通过类名访问
cout<<"通过类名访问 "<<endl;
Son::func();
Son::Base::func();
//子类出现和父类同名静态成员函数，也会隐藏父类中所有同名成员函数
//如果想访问父类中被隐藏的同名成员，需要加作用域
//Son::func(100); //❌，因为父类中重载的被隐藏了
Son::Base::func(100)；
}
5.7 多继承语法
C++中允许一个类继承多个类（一个子类多个父类）
class 子类 ： 继承方式 父类1，继承方式 父类2，···
多继承可能会引发父类中有同名成员出现，需要加作用域区分 C++实际开发中不建议使用多继承
class Base1
{
public:
Base1()
{
m_A=100;
}
int m_A;
};
class Base2
{
public:
Base2()
{
m_A=200;
}
int m_A;
};
//子类 需要继承Base1和Base2
class Son:public Base1,public Base2
{
public:
Son
{
m_C=300;
m_D=400;
}
int m_C;
int m_D;
};
void test1()
{
Son s;
cout<<"sizeof Son="<<sizeof(s)<<endl; //16字节
//当父类中出现同名成员，需要加作用域区分
cout<<"Base1::m_A="<<s.Base1::m_A<<endl; //100
cout<<"Base2::m_A="<<s.Base2::m_A<<endl; //200
}
5.8 菱形继承
概念：
1、两个派生类（子类）继承同一个基类（父类）
又有某一个类（孙子类）同时继承两个派生类（子类），则称菱形继承或钻石继承
问题：
//动物类
class Animal
{
public:
m_age;
};
//利用虚继承可以解决菱形继承的问题
//在继承之前 加上关键字 virtual 变为虚继承
//Animal类成为虚基类
//羊类
class Sheep : virtual public Animal{};
//驼类
class Tuo : public Animal{};
//羊驼类
class SheepTuo:public sheep,public Tuo{};
void test1()
{
SheepTuo st;
st.Sheep::m_age=18;
st.Tuo::m_age=28;
//当菱形继承，两个父类拥有相同数据，需要加以作用域区分
cout<<"st.Sheep::m_age="<<st.Sheep:: m_age<<endl; //28
cout<<"st.Tuo::m_age="<<st.Tuo::m_age<<endl; //28
cout<<"st."<<st.m_age<endl; //28，变为虚继承后，st.m_age也不会出现指向不明确的情况
//这份数据（年龄）我们只需要一份就可以，但菱形继承导致数据有两份，资源浪费
}
//Animal不是虚基类时：class Sheep : public Animal{};
资源浪费情况：有两份m_age
//虚继承之后，只有一份m_age
vbptr表示虚基类指针（v：virtual，b：base，ptr：pointer），指向一个虚基类表格vbtable
指向一个虚基类表格
8和4是偏移量
只有一份m_age数据
1082
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
