c++面向对象OOP

本阶段主要针对c++面向对象编程。

1. 内存分区模型

c++程序在执行时，将内存大方向划分为4个区域

代码区：存放函数体的二进制代码；由操作系统进行管理
全局区：存放全局变量，静态变量，常量；由操作系统进行管理
栈区：，存放函数的参数值，局部变量；由编译器自动分配释放
堆区：new开辟的数据区；由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收

目的：不同区域存放的数据，其生命周期不同（作用域），方便我们灵活编程

1.1 程序运行前

在程序编译后，生成了exe可执行文件，未执行该程序前分为两个区域

代码区：

存放CPU执行的机器指令
是共享的，共享的目的是对于频繁被执行的程序，只需要在内存中有一份代码即可
是只读的，只读的原因是防止程序意外修改了它的指令

全局区：

存放全局变量，静态变量，
全局区还包含了常量区，字符串常量和全局常量也存放在此（局部常量，局部变量在栈区）
该区域的数据在程序结束后由操作系统释放

总结：

c++程序在运行前分为全局区和代码区
代码区的特点是共享和只读
全局区中存放全局变量、静态变量、常量区
常量区中存放了const修饰的全局常量和字符串常量

1.2 程序运行后

栈区：由编译器自动分配和释放，存放函数的参数值，局部变量等；栈区开辟的数据空间，在函数执行完后，由编译器自动释放。

注意事项：函数不要返回局部变量的地址，会产生越界访问。为了解决频繁调用小函数，大量消耗栈内存的问题，引入了 inline 修饰符，表示为内联函数。其原理是将函数加入了代码中，可能会造成代码体积膨胀。类中的成员函数默认都是内联的。inline函数是#define 宏定义，在函数方面的优化版本。

堆区：由程序员分配释放，若程序员不释放，程序结束时由操作系统回收；c++中主要利用new在堆区开辟内存。

new操作符：堆区开辟用new，释放用delete。利用new创建的数据，会返回该数据对应的类型的指针。

int * a = new int(10);//创建变量
delete a;


int * arr = new int[10]; //创建数组
delete[] arr;

2. 引用

作用：给变量起别名

数据类型 &别名 = 原名

注意事项：

必须初始化
初始化之后不可改变

函数传参时，可以利用引用的技术，让形参修饰实参

int swap(int &a, int &b)

引用可以作为函数的返回值（1.不要返回局部变量 2.函数调用作为左值）；c++推荐用引用技术，因为语法方便；引用的本质，是指针常量。

常量引用：在函数形参列表中，可以加const修饰形参，防止形参改变实参。

3. 函数提高

函数的形参列表可以有默认值，该默认值只能设置一次，当函数声明时设置了，函数定义时就不能设置了。

函数的形参列表中可以有占位参数，用来做占位，调用函数时必须填补该位置。（前置++和后置++的运算符重载中使用了占位参数）

返回值类型 函数名（数据类型）{}

函数重载：同一作用域内，具有相同函数名，不同参数列表的函数；“返回值不同”不可以作为重载条件。

重载函数用来命名一组功能相似的函数，减少了函数名，避免了命名空间的污染，增强的程序可读性。

所有支持函数重载的语言都面临两个问题：第一，如何解决命名冲突（形参）；第二，如何确定调用的是哪一个版本的重载。

编译时，会将函数名进行映射，后面加上形参列表，例如：max（int a, char b）会变成 Z3maxic，前面的数字表示命名空间。

匹配时，会依次按照下列规则来判断。

精确匹配：参数匹配而不做转换，或者只是做微不足道的转换，如数组名到指针、函数名到指向函数的指针、T到const T；
提升匹配：即整数提升（如bool 到 int、char到int、short 到int），float到double
使用标准转换匹配：如int 到double、double到int、double到long double、Derived*到Base*、T*到void*、int到unsigned int；
使用用户自定义匹配；
使用省略号匹配：类似printf中省略号参数

如果在最高层有多个匹配函数找到，调用将被拒绝（因为有歧义、模凌两可）。

这个四个解析步骤所做的事情大致如下：

由匹配文法中的函数调用，获取函数名；
获得函数各参数表达式类型；
语法分析器查找重载函数，符号表内部经过重载解析返回最佳的函数
语法分析器创建抽象语法树，将符号表中存储的最佳函数绑定到抽象语法树上

4. 类和对象

三大特性：封装、继承、多态

万事万物皆可为对象，对象上有其属性和行为；类中的属性和行为统一称为成员

属性：成员属性，成员变量

行为：成员函数，成员方法

4.1 封装

封装的意义：

将属性和行为作为一个整体，表现生活中的事物
将属性和行为加以权限控制
- public（公共权限）：类内可以访问，类外可以
- protected（保护权限）：类内可以；类外不可以，子类可以访问
- private（私有权限）：类内可以；类外不可以，子类不可以访问

class 类名{访问权限：属性 / 行为};

struct 和 class的区别，在于默认权限：struct 默认权限为 public ；class 默认权限为 private .

头文件中声明，源文件中实现；将成员变量设置为私有之后，可以通过成员方法：1.控制读写权限 2.验检测数据的有效性。

4.2 对象的初始化和清理

4.2.1 构造函数和析构函数

构造函数：初始化，在创建对象时为对象的成员变量赋值，构造函数由编译器自动调用。

类名（）{}

没有返回值，且不写void
函数名称与类名相同
可以有参数，因此可以重载
创建对象时会自动调用一次

析构函数：在对象销毁前，系统自动调用，执行一些清理工作。

~类名（）{}

没有返回值和 void
~
没有参数，因此不可以重载
销毁前自动调用一次

当未提供构造和析构函数时，编译器会提供，且其是空实现。只有默认拷贝函数是值拷贝。

4.2.2 构造函数的分类及调用

两种分类方式

按参数：有参构造和无参构造
按类型：普通构造和拷贝构造（参数是引用的对象）

三种调用方式：括号法；显示法；隐式转换法

拷贝构造函数调用时机

使用一个已经创建完毕的对象来初始化一个新对象
值传递的方式给函数参数传值（传参）
以值方式返回局部对象（返回值）

拷贝函数的调用规则

如果用户定义有参构造函数，c++不再提供默认无参构造，但是会提供默认拷贝构造
如果用户定义拷贝构造函数，c++不再提供其他构造函数

深拷贝和浅拷贝

浅拷贝：简单的赋值拷贝操作（会带来问题：堆区的内存重复释放）
深拷贝：在堆区重新申请空间，进行拷贝操作（解决了浅拷贝的问题）

总结：如果属性在堆区开辟，需要自己提供拷贝构造函数，防止浅拷贝带来的问题。

初始化列表：用于初始化属性

构造函数（数据结构，值1，数据结构 值2 ···）：属性1（值2），属性1（值2），···{}

类对象可以作为类成员，构造时，先构造对象成员，再构造本类（符合先有零件，再有整体的直观）。析构顺序相反。

静态成员变量
- 所有对象共享同一份数据
- 在编译阶段分配内存
- 类内声明，类外初始化
静态成员函数
- 所有对象共享同一个函数
- 静态成员函数只能访问静态成员变量

c++编译器给类添加4个函数

默认构造函数（无参，函数体为空）
默认析构函数（无参，函数体为空）
默认拷贝构造函数，对属性进行值拷贝
赋值运算符 operator= ，对属性进行值拷贝

4.3 c++对象模型和 this 指针

成员变量和成员函数分开储存。只有非静态成员变量在类上。

每一个非静态成员函数只会诞生一份函数实例，也就是说，多个同类型的对象会共用一块代码。

c++通过提供 this 指针来帮助函数实例区分是哪一个对象调用自己。this 指针的本质是一个指针常量。

this 指针指向被调用的成员函数所属的对象。

当形参和成员变量同名时，可用 this 指针来区分（this.age = age）
在类的非静态成员函数中返回对象本身，可使用 return *this

空指针调用成员函数，如果用到this，需要加以判断保持代码的健壮性。

if(this == NULL) return;

const 修饰成员函数

常函数

成员函数后加 const 后我们称这个函数为常函数
常函数内的成员属性无法被修改，若想修改，需要在成员属性声明时加关键字 mutable 。

常对象

声明对象前加 const 称该对象为常对象
常对象只能调用常函数（防止普通成员函数修改成员属性）

友元：让一个函数或者类访问另一个类中的私有成员。关键字为 friend

三种实现

全局函数做友元（在类内声明为友元）
类做友元
成员函数做友元

4.4 运算符重载

本质上还是函数重载。

对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型

可以通过成员函数重载，也可以通过全局函数重载。

加法运算符重载：实现两个自定义数据类型相加的运算
左移运算符重载：输出自定义的数据类型
递增运算符重载：实现自己的整型数据（用占位参数区分前置递增和后置递增，前置递增返回引用，后置递增返回值）
赋值运算符重载：解决浅拷贝的问题
关系运算符重载：可以让两个自定义对象进行对比操作
函数调用运算符重载：函数调用运算符（）也可以重载，重载后也被称为仿函数

4.5 继承

减少重复代码

class 子类：继承方式 父类

子类，也成为派生类（表示个性）

父类，也称为基类（表示共性）

继承方式：

公共继承
保护继承
私有继承

继承中的对象模型：从父类继承过来的成员，哪些属于子类对象？

所有非静态成员属性都会被继承。私有成员属性被编译器隐藏了，无法访问。

//利用开发人员命令提示工具查看对象模型
//跳转盘符
//cd 具体路径下
cl /d1 reportSingleClassLayout类名 文件名

继承同名成员处理方式

访问子类同名成员直接访问即可
访问父类童名成员需要加作用域
当子类和父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域可以访问到父类中同名函数

c++允许多继承，但实际开发中不建议使用

菱形继承，又称钻石继承：利用虚继承可以解决菱形继承问题

虚继承后，子类继承了虚基类指针，指向虚基类表，表中是实际数据的偏移量。

4.6 多态

静态多态（编译时确定函数地址）：函数重载 和 运算符重载属于静态多态，复用函数名
动态多态（运行时确定函数地址）：派生类 和 虚函数实现运行时多态

多态满足条件

有继承关系
子类重写父类中的虚函数

多态使用条件：父类指针或引用指向子类对象

重写：函数返回值类型函数名参数列表完全一致称为重写

多态的优点：

代码组织结构清晰
可读性强
利于前期和后期的扩展以及维护

c++开发提倡利用多态设计程序结构，因为多态优点很多

多态中，父类的虚函数实现通常毫无意义，因此可以改成纯虚函数。

当类中有了纯虚函数，就变成了抽象类

抽象类特点

无法实例写抽象类中的纯虚函数，否则也属于抽象类

虚析构和纯虚析构

多态使用时，如果子类中有属性开辟到堆区，那么父类指针释放子类对象时不干净，因此，需要走将父类中的析构函数改为 虚析构 或者 纯虚析构。

虚析构和纯虚析构共性：

可以解决父类指针释放子类对象
都需要有具体的函数实现

虚析构和纯虚析构区别：如果是纯虚析构，该类属于抽象类，无法实例化对象

//虚析构
virtual ~类名（）{}

//纯虚析构
virtual ~类名（）=0；
类名：：~类名（）{}

5. 文件操作

通过文件可以将数据持久化

c++中对文件操作需要包含头文件<fstream>

文本文件：以ASCII码形式存储
二进制文件：以二进制形式存储

操作文件的三大类

ofstream：写操作
ifstream：读操作
fstream：读写操作

写文件

1. 包含头文件   

   #include <fstream>

2. 创建流对象  

   ofstream ofs;

3. 打开文件

   ofs.open("文件路径",打开方式);

4. 写数据

   ofs << "写入的数据";

5. 关闭文件

   ofs.close();

打开方式	解释
ios::in	为读文件而打开文件
ios::out	为写文件而打开文件
ios::ate	初始位置：文件尾
ios::app	追加方式写文件
ios::trunc	如果文件存在先删除，再创建
ios::binary	二进制方式

注意： 文件打开方式可以配合使用，利用 | 操作符

例如：用二进制方式写文件 ios::binary | ios:: out

读文件

1. 包含头文件   

   \#include <fstream\>

2. 创建流对象  

   ifstream ifs;

3. 打开文件并判断文件是否打开成功

   ifs.open("文件路径",打开方式);

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)
    {
        cout << c;
    }

5. 关闭文件

   ifs.close();

二进制方式写文件主要利用流对象调用成员函数write

函数原型：ostream& write(const char * buffer,int len);

参数解释：字符指针buffer指向内存中一段存储空间。len是读写的字节数

        ofstream ofs("person.txt", ios::out | ios::binary);
    
    //ofs.open("person.txt", ios::out | ios::binary);

    Person p = {"张三"  , 18};

    //4、写文件
    ofs.write((const char *)&p, sizeof(p));

二进制方式读文件主要利用流对象调用成员函数read

函数原型：istream& read(char *buffer,int len);

参数解释：字符指针buffer指向内存中一段存储空间。len是读写的字节数

#include <fstream>
#include <string>

class Person
{
public:
    char m_Name[64];
    int m_Age;
};

void test01()
{
    ifstream ifs("person.txt", ios::in | ios::binary);
    if (!ifs.is_open())
    {
        cout << "文件打开失败" << endl;
    }

    Person p;
    ifs.read((char *)&p, sizeof(p));

    cout << "姓名： " << p.m_Name << " 年龄： " << p.m_Age << endl;
}

posted @ 2021-11-23 18:13 木木木999 阅读(71) 评论(0) 收藏举报

刷新页面返回顶部