文章目录
- 一、继承
- 1 继承中的对象模型
- 2 继承中构造和析构顺序
- 3 继承中同名属性和函数处理方式（隐藏）
- 4 继承同名静态成员属性和函数处理方式
- 5 多继承语法
- 6 菱形继承（虚继承）
- 二、多态
- 1 多态的原理剖析（虚函数表指针）
- 2 纯虚函数和抽象类
- 3 虚析构和纯虚析构（解决父类指针管理堆区子类析构函数）
- 三、文件操作
- 1 文本文件
- 1.1 写文件(ofstream)
- 1.2 读文件(ifstream)
- 2 二进制文件
- 2.1 写文件(ofstream)
- 2.2 读文件(ifstream)
一、继承
- 利用继承的技术，减少重复代码
- 语法：
class 子类名：继承方式 父类名
继承方式一共有三种：
- 公共继承(public)
- 保护继承(protected)
- 私有继承(private)
1 继承中的对象模型
- 父类中私有成员也是被子类继承下去了，只是由于编译器给隐藏后访问不到
- 在父类中所有非静态的成员属性都会被子类继承下去
// 继承中的对象模型
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 << "size of Son= " << sizeof(Son) << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
2 继承中构造和析构顺序
- 创建子类对象，也会调用父类的构造函数
- 先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反。（栈的先进后出）
3 继承中同名属性和函数处理方式（隐藏）
- 访问子类同名成员，直接访问即可
s.m_A - 访问父类同名成员，需要加作用域
s.Base::m_A- 子类会隐藏掉父类中所有同名成员函数（重载的部分也隐藏）
- 若两个函数参数相同，但是基类函数不是虚函数，则会被隐藏。和重写的区别在于基类函数是否是虚函数。
- 若两个函数参数不同，无论基类函数是不是虚函数，都会被隐藏，两个函数在同一个类中。和重载的区别在于两个函数不在同一个类中。
// 继承中同名成员处理
class Base
{
public:
Base()
{
m_A = 100;
}
void func()
{
cout << "Base-func()调用" << endl;
}
void func(int a)
{
cout << "Son-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;
};
// 1. 同名成员属性处理
void test01()
{
Son s;
cout << "Son 下 s.m_A= " << s.m_A << endl;
// 如果通过子类对象，访问到父类中同名成员，需要加作用域
cout << "Base 下 s.m_A=" << s.Base::m_A << endl;
}
// 2. 同名成员函数处理
void test02()
{
Son s;
s.func(); // 直接调用是子类中的同名成员
s.Base::func();
// 如果子类中出现和父类同名的成员函数，子类的同名成员会隐藏掉父类中所有同名成员函数
// 如果想访问到父类中被隐藏的同名成员函数，需要加作用域
// s.func(100);
s.Base::func(100);
}
int main()
{
test01();
test02();
system("pause");
return 0;
}
4 继承同名静态成员属性和函数处理方式
静态成员变量的特点：
- 所以对象都共享同一份数据
- 编译阶段就分配内存
- 类内声明，类外初始化
静态成员函数的特点：
- 只能访问静态成员变量，不能访问非静态成员变量
- 所以对象共享同一份函数实例
静态成员和非静态成员出现同名，处理方式一致：（只不过有两种访问方式：对象 和 类名）
- 访问子类同名成员 直接访问即可
s.m_ASon::m_A - 访问父类同名成员 需要加作用域
s.Base::m_ASon::Base::m_A
// 继承中同名静态成员处理
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;
// 1. 同名静态成员属性
void test01()
{
cout << "通过对象访问： " << endl;
// 1、通过对象访问数据
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;
}
// 2. 同名静态成员函数处理
void test02()
{
cout << "通过对象访问： " << endl;
// 通过对象访问
Son s;
s.func();
s.Base::func();
// 通过类名访问
cout << "通过类名访问： " << endl;
Son::func();
Son::Base::func(); //
// 当子类与父类拥有同名的成员函数，子类会隐藏掉父类中所有同名成员函数，加作用域可以访问到父类中同名函数。
Son::Base::func(100);
}
int main()
{
test01();
test02();
system("pause");
return 0;
}
5 多继承语法
- C++实际开发中不建议用多继承
- 语法：
class 子类：继承方式 父类1，继承方式 父类2... - 多继承可能会引发父类中有同名成员出现，需要加作用域区分
s.Base1::m_As.Base2::m_A
// 多继承语法
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, m_D;
};
void test01()
{
Son s;
sizeof(s);
cout << "size of Son= " << sizeof(Son) << endl; // 16
// 当父类中出现同名的成员
cout << "Base1::m_A= " << s.Base1::m_A << endl;
cout << "Base2::m_A= " << s.Base2::m_A << endl;
}
int main()
{
test01();
// test02();
system("pause");
return 0;
}
6 菱形继承（虚继承）
菱形继承概念： 两个派生类继承同一个基类，又有某个类同时继承着两个派生类。
解决方式（利用虚继承）：
- 菱形继承带来的主要问题是子类继承两份相同的数据，导致资源浪费及毫无意义
- 利用虚继承可以解决菱形继承问题
- 继承方式之前加入关键字
virtual变为虚继承class Sheep : virtual public Animal {}；
// 动物类
class Animal
{
public:
int m_Age;
};
// Animal称为 虚基类（最大的类）
class Sheep : virtual public Animal
{
};
// 驼类
class Tuo : virtual public Animal
{
};
// 羊驼类
class SheepTuo : public Sheep, public Tuo
{
};
void test01()
{
SheepTuo st;
st.Sheep::m_Age = 18;
st.Tuo::m_Age = 28;
// 当菱形继承，两个父类拥有相同数据，需要加以作用域区分
cout << "st.Sheep::m_Age= " << st.Sheep::m_Age << endl;
cout << "st.Tuo::m_Age= " << st.Tuo::m_Age << endl;
cout << "st.m_Age = " << st.m_Age << endl; // 28
// 利用虚继承可以直接访问，不会有二义性
}
int main()
{
test01();
system("pause");
return 0;
}
- 没用虚函数（sheepTuo）
- 用虚函数（sheepTuo）(不会出现二义性)
- 从父类中拿到的只是一个虚基类指针而已
二、多态
- C++开发提倡利用多态设计程序架构，因为多态优点很多
- 开闭原则：对拓展进行开放，对修改进行关闭
多态分为两类：
- 静态多态：函数重载 和 运算符重载 属于静态多态，复用函数名
- 动态多态：派生类和虚函数实现运行时多态
静态多态和动态多态区别：
- 静态多态的函数地址早绑定------编译阶段确认函数地址
- 动态多态的函数地址晚绑定------运行阶段确认函数地址
多态满足条件：
- 有继承关系
- 父类必须写虚函数，子类可写可不写
- 子类重写父类中的虚函数
- 重写：函数（返回值类型 函数名 参数列表）完全一致称为重写
多态使用条件：
- 父类指针或引用（指针必须开辟堆区）指向子类对象
class Animal
{
public:
// 虚函数
virtual void speak()
{
cout << "动物在说话" << endl;
}
};
class Cat : public Animal
{
public:
// 重写 函数的返回值类型 函数名和参数列表要完全相同
void speak()
{
cout << "小猫在说话" << endl;
}
};
class Dog : public Animal
{
public:
void speak()
{
cout << "小狗在说话" << endl;
}
};
// 父类的指针或引用 指向子类对象
void doSpeak(Animal &animal) // Animal &animal =cat;
{ // 子类可以转父类，父类不能转子类
animal.speak();
}
void test01()
{
Cat cat;
doSpeak(cat);
Dog dog;
doSpeak(dog);
}
int main()
{
test01();
system("pause");
return 0;
}
1 多态的原理剖析（虚函数表指针）
- 子类继承父类，同时也继承了虚函数表
- 虚函数表指针指向虚函数表（记录虚函数的内容）
- 通俗讲就是虚函数表指针指向虚函数表本身，有重写就替换
- Animal(父类)
- Cat(子类)
2 纯虚函数和抽象类
- 通常父类中虚函数的实现是毫无意义的，主要都是调用子类中重写的内容。因此可以将虚函数改为纯虚函数
- 纯虚函数语法：
virtual 返回值类型 函数名 （参数列表）=0; - 当类中有了纯虚函数，这个类也成为抽象类
纯虚函数特点：
- 提供接口（父类虚函数表指针指向子类对象）
- 不做任何实现
抽象类特点：
- 无法实例化对象
- 子类必须重写抽象类中的纯虚函数，否则也属于抽象类
// 纯虚函数和抽象类
class Base
{
public:
// 1、无法实例化对象
// 2、抽象类的子类必须要重写父类中的纯虚函数，否则也属于抽象类
virtual void func() = 0; // 纯虚函数
};
class Son : public Base
{
public:
virtual void func()
{
cout << "func函数调用" << endl;
};
};
void test01()
{
Base *base = new Son;
base->func();
}
int main()
{
test01();
system("pause");
return 0;
}
3 虚析构和纯虚析构（解决父类指针管理堆区子类析构函数）
- 如果子类中有属性开辟到堆区（栈区自动释放），那么父类指针在释放时无法调用到子类的析构函数
- 父类的引用和开辟到栈区的指针可以调用子类析构和构造
- 解决方式：将父类中的析构函数改为虚析构或纯虚析构
- 如果子类中没有堆区数据，可以不写虚析构或纯虚析构（
最好有继承关系就写虚析构！）
虚析构和纯虚析构共性：（都需要函数实现）
- 可以解决父类指针释放子类对象
- 都需要有具体的函数实现
虚析构和纯虚析构区别：
- 如果是纯虚析构，该类属于抽象类，也无法实例化对象
- 虚析构语法：
virtual ~类名(){}; - 纯虚析构语法：
virtual ~类名（）=0； - 纯虚析构函数必须有实现。
如果类包含纯虚析构函数，则必须为纯虚析构函数提供函数体
- 原因是因为析构函数（与其它函数不同）实际上并未被 “重写”，而是始终以派生类的相反顺序调用它们。这意味着派生类的析构函数将首先被调用，然后调用基类的析构函数。
- 如果未提供纯虚析构函数的定义，那么在销毁对象期间将调用什么函数体？
// 虚析构和纯虚析构
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);
}
~Cat()
{
if (m_Name != NULL)
{
cout << "Cat的析构函数调用" << endl;
delete m_Name;
m_Name = NULL;
}
}
virtual void speak()
{
cout << *m_Name << "小猫在说话" << endl;
}
string *m_Name;
};
void test01()
{
Animal *animal = new Cat("Tom");
animal->speak();
// 开辟到堆区的指针，手动释放
delete animal;
}
int main()
{
test01();
system("pause");
return 0;
}
Animal的构造函数调用
Cat的构造函数调用
Tom小猫在说话
Cat的析构函数调用
Animal的纯虚析构函数调用
三、文件操作
- 程序运行时产生的数据都属于临时数据，程序一旦运行结束都会被释放
- 通过文件可以将数据持久化
- C++中对文件操作需要包含头文件
<fstream>(文件流)
文件类型分为两种：
- 文本文件（可以看到）
- 文件以文本的ASCII码形式存储在计算机中
- 二进制文件
- 文件以文本的二进制形式存储在计算机中，用户一般不能直接读懂它们
操作文件的三大类：
- ofstream：写操作（输出）
- ifstream：读操作（输入）
- fstream：读写操作（输入、输出）
1 文本文件
1.1 写文件(ofstream)
写文件步骤如下：
- 包含头文件
#include<fstream> - 创建流对象
ofstream ofs；（名字无所谓） - 打开文件
ofs.open("文件路径"，打开方式)； - 写数据
ofs<<"写入的数据"； - 关闭文件
ofs.close（）；
文件打开方式：
| 打开方式 | 解释 |
|---|---|
ios::in | 为读文件而打开文件 |
ios::out | 为写文件而打开文件 |
ios::ate | 初始位置: 文件尾 |
ios::app | 追加方式写文件 |
ios::trunc | 如果文件存在先删除，再创建 |
ios::binary | 二进制方式 |
注意：文件打开方式可以配合使用，使用 | 操作符
- 例如：用二进制的方式写文件
ios::binary | ios::out
#include <fstream>
// 文本文件 写文件
void test01()
{
// 1.包含头文件 fstream
// 2.创建流对象
ofstream ofs;
// 3.指定打开方式
// 没有指定路径和当前.cpp的目录一样
// 路径可以写成绝对路径或者相对路径，或直接写文件名
ofs.open("test1.txt", ios::out);
// 4.写内容
ofs << "姓名：张三" << endl;
ofs << "性别：男" << endl;
ofs << "年龄: 18" << endl;
// 5.关闭文件
ofs.close();
}
int main()
{
test01();
system("pause");
return 0;
}
1.2 读文件(ifstream)
- 读文件与写文件步骤相似，但是读取方式相对于比较多
读文件步骤如下：
- 包含头文件
#include<fstream> - 创建流对象
ifstream ifs; - 打开文件并判断文件是否打开成功
ifs.open("文件路径"，打开方式)；- 判断文件是否打开成功
ifs.is_open()
- 判断文件是否打开成功
- 读数据 四种方式读取(程序中)
- 关闭文件
ifs.close();
文件打开方式：
| 打开方式 | 解释 |
|---|---|
ios::in | 为读文件而打开文件 |
ios::out | 为写文件而打开文件 |
ios::ate | 初始位置: 文件尾 |
ios::app | 追加方式写文件 |
ios::trunc | 如果文件存在先删除，再创建 |
ios::binary | 二进制方式 |
#include <fstream>
#include <string>
// 文本文件 读文件
void test01()
{
// 1.包含头文件
// 2.创建流对象
ifstream ifs;
// 3.打开文件并判断是否打开成功
ifs.open("test.txt", ios::in);
// 判断文件是否打开成功
if (!ifs.is_open())
{
cout << "文件打开失败了" << endl;
return;
}
// 4.读数据
// 第一种
char buf[1024] = {0};
while (ifs >> buf) // 读到头返回一个假的标志
{
cout << buf << endl;
}
// 第二种
char buf[1024] = {0};
// ifs对象内有成员函数
// ifs.getline(char *（传入首地址），sizeof()(统计字节数))
while (ifs.getline(buf, sizeof(buf)))
{ // getline()返回bool类型
cout << buf << endl;
}
// 第三种（较好）
string buf;
// 全局函数getline
while (getline(ifs, buf))
{
cout << buf << endl;
}
// 第四种 不推荐
char c; // EOF判断是否没有到达文件尾
while ((c = ifs.get()) != EOF) // EOF end of file
{ // 中文每个占多个字节，用endl就分开了
cout << c;
}
// 5.关闭文件
ifs.close();
}
int main()
{
test01();
return 0;
}
2 二进制文件
文件打开方式：
| 打开方式 | 解释 |
|---|---|
ios::in | 为读文件而打开文件 |
ios::out | 为写文件而打开文件 |
ios::ate | 初始位置: 文件尾 |
ios::app | 追加方式写文件 |
ios::trunc | 如果文件存在先删除，再创建 |
ios::binary | 二进制方式 |
- 以二进制的方式对文件进行读写操作
- 打开方式要指定为
ios::binary
2.1 写文件(ofstream)
- 二进制方式写文件主要利用输出流
ofstream调用成员函数ofs.write（）wirte()函数原型：ofs.write(const char* buffer, sizeof(len);
#include <fstream>
// 二进制文件 写文件
class Person
{
public:
// 对文件操作，写字符串最好不要用C++的string，会出现问题
char m_Name[64]; // 姓名
int m_Age; // 年龄
};
void test01()
{
// 1.包含头文件
// 2.创建流对象
// ofs对象有构造函数，直接初始化
ofstream ofs("person.txt", ios::out | ios::binary);
// 3.打开文件
// ofs.open("person.txt", ios::out | ios::binary);
// 4.写文件
Person p = {"张三", 18};
// 强制转换，原来为Person*
ofs.write((const char *)&p, sizeof(Person));
// 5.关闭文件
ofs.close();
}
int main()
{
test01();
return 0;
}
2.2 读文件(ifstream)
- 二进制方式读文件主要利用输入流
ifstream调用成员函数ifs.read() read()函数原型：ifs.read(char *buffer,sizeof(len));
#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 << endl;
cout << "年龄为：" << p.m_Age << endl;
// 5.关闭文件
ifs.close();
}
int main()
{
test01();
return 0;
}
