文章目录
- 继承
- 继承方式
- 继承中的对象模型
- 继承中构造和析构顺序
- 继承同名成员处理方式
- 继承同名<静态>成员处理方式
- 多继承语法
- 菱形继承
- 多态
- 多态案例1、计算器类
- 纯虚函数和抽象类
- 多态案例2、制作饮品
- 虚析构和纯虚析构
- 多态案例3、电脑组装
- 文件写操作
- 读文件
- 二进制写文件
- 二进制读文件
基于b站黑马c++视频做的笔记，仅供参考和复习！！！
继承
例如我们看到很多网站中，都有公共的头部，公共的底部，甚至公共的左侧列表，只有中心内容不同。
继承实现页面
继承好处：减少重复代码
语法： class 子类:继承方式 父类
子类 也称为 派生类或者基类
//公共页面
class BasePage
{
public:
void header(){
cout << "首页、公开课、登录、注册...(公共头部)" << endl;
}
void footer(){
cout << "帮助中心、交流合作、站内地图...（公共底部）" << endl;
}
void left(){
cout << "Java、Python、c++...(公共分类列表)" << endl;
}
};
//Java页面
//语法： class 子类:继承方式 父类
class Java :public BasePage
{
public:
void content(){
cout << "Java学科视频" << endl;
}
};
//Python页面
class Python :public BasePage
{
public:
void content(){
cout << "Python学科视频" << endl;
}
};
//C++页面
class CPP :public BasePage
{
public:
void content(){
cout << "CPP学科视频" << endl;
}
};
void test01()
{
cout << "Java下载视频页面如下：" << endl;
Java ja;
ja.header();
ja.footer();
ja.left();
ja.content();
cout << endl;
cout << "Python下载视频页面如下：" << endl;
Python py;
py.header();
py.footer();
py.left();
py.content();
cout << endl;
cout << "C++下载视频页面如下：" << endl;
CPP cpp;
cpp.header();
cpp.footer();
cpp.left();
cpp.content();
}
int main()
{
test01();
}
继承方式
- 公共继承
- 保护继承
- 私有继承
#include <iostream>
using namespace std;
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 = 20; //父类中的保护权限成员 到子类中依然是保护权限
//m_C = 30; //父类中的私有权限成员 子类访问不到
}
};
void test01()
{
Son1 s1;
s1.m_A = 100;
//s1.m_B = 100; //到Son1中m_B是保护权限 类外访问不到
}
//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; //在Son2中 m_A变为保护权限，因此类外访问不到
//s2.m_B = 200; //在Son2中 m_B是保护权限 不可以访问
}
//3、私有继承
class Son3 :private Base
{
public:
void func()
{
m_A = 100;//父类中的公共权限成员,到子类中变为 私有成员
m_B = 100;//父类中保护权限成员,到子类中变为 私有成员
//m_C = 100; //父类中的私有权限成员 子类访问不到
}
};
class GrandSon3 :public Son3
{
public:
void func(){
//m_A = 100; //到了Son3中 m_A变为私有，即使是儿子，也访问不到
//m_B = 100; //到了Son3中 m_B变为私有，即使是儿子，也访问不到
//m_C = 100;
}
};
void test03()
{
Son3 s3;
//s3.m_A = 100; //在Son3中 m_A变为私有权限成员，因此类外访问不到
//s3.m_B = 200; //在Son3中 m_B是私有权限成员 不可以访问
}
int main()
{
test01();
test02();
test03();
}
继承中的对象模型
父类在所有非静态成员属性都会被子类继承下去
//继承在的对象模型
class Base
{
public:
int m_A;
protected:
int m_B;
private:
int m_C;
};
class Son:public Base
{
public:
int m_D;
};
void test01()
{
//16个字节
//父类中私有成员属性 被编译器隐藏了，因此是访问不到，但确实被继承了
cout << "size of Son = " << sizeof(Son) << endl; //输出16个字节
}
int main()
{
test01();
}
继承中构造和析构顺序
总结:继承中 先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反
//继承在的构造和析构的顺序
class Base
{
public:
Base(){
cout << "Base构造函数！" << endl;
}
~Base(){
cout << "Base析构函数！" << endl;
}
};
class Son :public Base
{
public:
Son(){
cout << "Son构造函数！" << endl;
}
~Son(){
cout << "Son析构函数！" << endl;
}
};
void test01()
{
//Base b;
Son s;
}
int main()
{
test01();
}
继承同名成员处理方式
1、子类对象可以直接访问到子类中同名成员
2、子类对象加作用域可以访问到父类成员
3、当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域就要访问到父类中的同名函数
//继承中同名成员处理
class Base
{
public:
Base(){
m_A = 100;
}
void func(){
cout << "Base - func()调用" << endl;
}
void func(int a){
cout << "Base - func()调用" << endl;
}
int m_A;
};
class Son :public Base
{
public:
Son(){
m_A = 200;
}
void func(){
cout << "Son - func()调用" << endl;
}
int m_A;
};
//同名成员属性的处理方式
void test01()
{
Son s;
cout << "Son 下的m_A = " << s.m_A << endl;
//如果通过子类对象 访问到父类中同名成员，需要加作用域
cout << "Base 下的m_A = " << s.Base::m_A << endl;
}
//同名成员函数的处理方式
void test02()
{
Son s;
s.func(); //直接调用 调用时子类在的同名成员
s.Base::func(); //调用父类同名成员函数
//如果子类中出现和父类同名的成员函数，子类的同名成员会隐藏掉父类中"所有"同名成员函数
//如果想访问父类中被隐藏的同名成员函数，需要加作用域
s.Base::func(100);
}
int main()
{
test01();
test02();
}
继承同名<静态>成员处理方式
//继承中的同名静态成员处理方式
class Base
{
public:
static int m_A;
static void func(){
cout << "Base - static void func()" << endl;
}
static void func(int a){
cout << "Base - static void func(int a)" << 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 Son::m_A = 200;
//一、同名静态属性成员
void test01()
{
//1、通过对象访问
cout << "通过对象访问: " << endl;
Son s;
cout << "Son 下的m_A = " << s.m_A << endl;
cout << "Base 下的m_A = " << s.Base::m_A << endl;
//2、通过类名访问
cout << "通过类名访问: " << endl;
cout << "Son 下的m_A = " << Son::m_A << endl;
//第一个::代表通过类名方式访问 第二个::代表访问父类作用域下
cout << "Base 下的m_A = " << Son::Base::m_A << endl;
}
//二、同名静态函数成员
void test02()
{
//1、 通过对象访问
cout << "通过对象访问: " << endl;
Son s;
s.func();
s.Base::func();
//2、通过类名访问
cout << "通过类名访问: " << endl;
Son::func();
Son::Base::func();
//如果子类中出现和父类同名的成员函数，子类的同名成员会隐藏掉父类中"所有"同名成员函数
//如果想访问父类中被隐藏的同名成员函数，需要加作用域
s.Base::func(100);
}
int main()
{
//test01();
test02();
}
多继承语法
//多继承语法
class Base1
{
public:
Base1(){
m_A = 100;
}
int m_A;
};
class Base2
{
public:
Base2(){
m_A = 200;
}
int m_A;
};
//子类 需要继承Base1和Base2
//语法: class 子类：继承方式 父类1，继承方式 父类2
class Son :public Base1, public Base2
{
public:
Son(){
m_C = 300;
m_D = 400;
}
int m_C;
int m_D;
};
void test01()
{
Son s;
cout << "sizeof Son = " << sizeof(s) << endl;
//当父类中出现同名成员，子类使用时需要加作用域区分
cout << "m_A = " << s.Base1::m_A << endl;
cout << "m_A = " << s.Base2::m_A << endl;
}
int main()
{
test01();
}
菱形继承
//动物类
class Animal
{
public:
int m_Age;
};
//利用虚继承 解决菱形继承的问题
//继承之前 加上关键字 virtual 变为虚继承
// Animal类称为 虚基类
//羊类
class Sheep :virtual public Animal {};
//驼类
class Tuo :virtual public Animal {};
//羊驼类
class SheepTuo :public Sheep, public Tuo {};
void test01()
{
SheepTuo st;
st.Tuo::m_Age = 18;
st.Sheep::m_Age = 28;
//当菱形继承，两个父类拥有相同数据，需要加以作用域区分
cout << "st.Sheep::m_Age = " << st.Sheep::m_Age << endl;
cout << "st.Tuo::m_Age = " << st.Tuo::m_Age << endl;
//这份数据我们知道 只要有一份就可以了，菱形继承导致数据有两份，资源浪费
}
int main()
{
test01();
}
没有虚继承时
虚继承后
利用虚继承 解决菱形继承的问题。即通过继承之前 加上关键字 virtual 变为虚继承，Animal类称为 虚基类。此时对于Sheep类和Tuo类中就会产生虚基类指针通过地址偏移量都指向m_Age变量
多态
多态分为两类
- 静态多态: 函数重载 和 运算符重载属于静态多态，复用函数名
- 动态多态: 派生类和虚函数实现运行时多态
静态多态和动态多态区别：
- 静态多态的函数地址早绑定 - 编译阶段确定函数地址
- 动态多态的函数地址晚绑定 - 运行阶段确定函数地址
动态多态满足条件
1、有继承关系
2、子类重写父类的虚函数
//动物类
class Animal
{
public:
//虚函数
virtual void speak(){
cout << "动物在说话" << endl;
}
};
//猫类
class Cat :public Animal
{
public:
//重写 函数返回值类型 函数名 参数列表 完全相同
virtual void speak(){ //当子类重写父类的虚函数 子类中的虚函数表内部 会替换成子类的虚函数地址
cout << "小猫在说话" << endl;
}
};
//狗类
class Dog :public Animal
{
public:
virtual void speak(){
cout << "小狗在说话" << endl;
}
};
//执行说话的函数 动态多态的函数地址晚绑定，运行阶段确定函数地址
//动态多态使用
//父类的指针或者引用 执行子类对象
void doSpeak(Animal &animal) //Animal &animal = cat;
{
animal.speak();
}
void test01()
{
Cat cat;
doSpeak(cat);
Dog dog;
doSpeak(dog);
}
void test02()
{
cout << sizeof(Cat) << endl;
cout << sizeof(Animal) << endl;
}
int main()
{
test01();
test02();
}
父类
子类继承父类，重写虚函数
图中字节数是因为操作系统的位数不同，普遍为8字节。
多态案例1、计算器类
案例：计算器类
纯虚函数和抽象类
在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的内容。因此可以将虚函数改为纯虚函数
纯虚函数语法：virtual 返回值类型 函数名 （参数列表）= 0 ;
只要有一个纯虚函数，这个类称为抽象类
抽象类特点:
1、无法实例化对象
2、抽象类的子类 必须要重写父类中的纯虚函数，否则也属于抽象类
//纯虚函数和抽象类
class Base
{
public:
virtual void func() = 0; //纯虚函数
};
class Son :public Base
{
public:
virtual void func(){
cout << "func函数调用" << endl;
}
};
void test01()
{
//Base b; //抽象类是无法实例化对象
//new Base;//抽象类是无法实例化对象
//Son s;
//Base* bas = &s;
//简写如下式所示
Base * bas = new Son; //new创建了一个子类对象且父类指向它
bas->func();
}
int main()
{
test01();
}
多态案例2、制作饮品
案例：制作饮品
虚析构和纯虚析构
多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码
虚析构和纯虚析构共性：
- 可以解决父类指针释放子类对象
- 都需要有具体的函数实现
虚析构和纯虚析构区别：
- 如果是纯虚析构，该类属于抽象类，无法实例化对象
class Animal
{
public:
Animal(){
cout << "Animal构造函数调用" << endl;
}
//利用虚析构可以解决 父类指针释放子类对象时不干净的问题,即子类中有指针成员变量时
/*virtual ~Animal(){
cout << "Animal虚析构函数调用" << endl;
}*/
//纯虚析构 需要声明也需要实现 这一点和纯虚函数是不同的
//有了纯虚析构之后，这个类也属于抽象类，无法实例化对象
virtual ~Animal() = 0;
//纯虚函数
virtual void speak() = 0;
};
Animal::~Animal() //纯虚析构需要实现 因为有可能父类有些属性会开辟到堆区
{
cout << "Animal纯虚析构函数调用" << endl;
}
class Cat :public Animal
{
public:
Cat(string name){ //有参构造函数调用
cout << "Cat构造函数调用" << endl;
m_Name = new string(name); //name变量的地址指传给m_Name变量地址，使得m_Name指针指向name变量
}
virtual void speak(){
cout << *m_Name << "小猫在说话" << endl;
}
~Cat(){
if (m_Name != NULL){
cout << "Cat析构函数调用" << endl;
delete m_Name;
m_Name = NULL;
}
}
string * m_Name;
};
void test01()
{
Animal * animal = new Cat("Tom"); //输入参数原因，设置了有参构造函数，默认构造函数会取消，需要手动输入
animal->speak();
//父类指针在析构时候 不会调用子类中的析构函数，导致子类如果
//有堆区属性，出现内存泄漏
delete animal;
}
int main()
{
test01();
}
多态案例3、电脑组装
案例：电脑组装
文件写操作
程序运行时产生的数据都属于临时数据，程序一旦运行结束都会被释放，通过文件可以将数据持久化。
C++中对文件操作需要包含头文件 。
文件类型分为两种：
文本文件 - 文件以文本的ASCII码形式存储在计算机中
二进制文件 - 文件以文本的二进制形式存储在计算机中，用户一般不能直接读懂它们
操作文件的三大类:
ofstream：写操作
ifstream： 读操作
fstream ： 读写操作
文件打开方式：
| 打开方式 | 解释 |
|---|---|
| ios::in | 为读文件而打开文件 |
| ios::out | 为写文件而打开文件 |
| ios::ate | 初始位置：文件尾 |
| ios::app | 追加方式写文件 |
| ios::trunc | 如果文件存在先删除，再创建 |
| ios::binary | 二进制方式 |
注意： 文件打开方式可以配合使用，利用 | 操作符
**例如：**用二进制方式写文件 ios::binary | ios:: out
#include <iostream>
using namespace std;
#include <fstream> //头文件包含
//文本文件 写文件
void test01()
{
//1、包含头文件 fstream
//2、创建流对象
ofstream ofs;
//3、指定打开方式
ofs.open("test.txt", ios::out);
//4、写内容
ofs << "姓名：张三" << endl;
ofs << "年龄：18" << endl;
//5、关闭文件
ofs.close();
}
int main()
{
test01();
}
读文件
#include <fstream>
//文本文件 读文件
void test01()
{
//1、包含头文件
//2、创建流对象
ifstream ifs;
//3、打开文件 并且判断是否打开成功
ifs.open("test.txt", ios::in);
if (!ifs.is_open()){ //利用is_open函数可以判断文件是否打开成功
cout << "文件打开失败" << endl;
return;
}
//4、读数据
//第一种
/*char buf[1024] = { 0 };
while (ifs >> buf){
cout << buf << endl;
}*/
//第二种
//char buf[1024] = { 0 };
//while (ifs.getline(buf,sizeof(buf)))
//{
// cout << buf << endl;
//}
//第三种
/*string buf;
while (getline(ifs, buf)){
cout << buf << endl;
}*/
//第四种
char c;
while ((c = ifs.get())!= EOF){ //EOF 文件尾
cout << c;
}
//5、关闭文件
ifs.close();
}
int main()
{
test01();
}
二进制写文件
#include <fstream>
//二进制文件 写文件
class Person
{
public:
char m_Name[64]; //姓名
int m_Age;//年龄
};
void test01()
{
//1、包含头文件
//2、创建流对象
ofstream ofs("Person.txt", ios::out | ios::binary);
//3、打开文件
//ofs.open("Person.txt",ios::out |ios::binary);
//4、写文件
Person p = { "张三",18 };
ofs.write((const char*)&p, sizeof(Person));
//5、关闭文件
ofs.close();
}
int main()
{
test01();
}
二进制读文件
#include <fstream>
class Person
{
public:
char m_Name[64]; //姓名
int m_Age;//年龄
};
//二进制 读文件
void test01()
{
//1、包含头文件
//2、创建流对象
ifstream ifs;
//3、打开文件 判断文件是否打开成功
ifs.open("Person.txt", ios::in | ios::binary);
if (!ifs.is_open()){
cout << "文件打开失败" << endl;
return;
}
//4、读文件
Person p;
ifs.read((char*)&p,sizeof(Person));
cout << "姓名: " << p.m_Name << " 年龄：" << p.m_Age << endl;
//5、关闭文件
ifs.close();
}
int main()
{
test01();
}
![BUUCTF Reverse/[2019红帽杯]Snake](https://img-blog.csdnimg.cn/direct/7658b43febcd45cd80fd2911ceee5aa2.png)
