C/C++进阶(一)--内存管理

更多精彩内容.....

🎉❤️播主の主页✨😘

Stark、-CSDN博客

本文所在专栏：

学习专栏C语言_Stark、的博客-CSDN博客

其它专栏：

数据结构与算法_Stark、的博客-CSDN博客

项目实战C系列_Stark、的博客-CSDN博客

座右铭：梦想是一盏明灯，照亮我们前行的路，无论风雨多大，我们都要坚持不懈。

在前面，我们学习C语言的时候，我们就提到过内存的概念，介绍了内存的分区以及各个区域负责的事情，并且给出了一些内存函数使用。

C语言的内存知识_c语言内存-CSDN博客

本节我们主要是学习内存的管理。

一、内存分区模型

一般我们将内存划为四个或五个区，而真实的内存远远不止这四五个区。我们先来回顾一下内存分区的知识：

Ⅰ.栈区(stack)：由编译器自动分配释放。存放函数的参数值，局部变量的值等。

Ⅱ.堆区(heap)：一般由程序员分配释放(动态内存申请和释放)。若程序员不释放，程序结束时可能由操作系统回收。

Ⅲ.全局区(global)/静态区(static)：全局变量和静态变量是放在一块的，初始化的全局变量和静态变量在一块儿区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块儿区域，该区域在程序结束后由操作系统释放。

Ⅳ.常量区(const)：字符串常量和其它常量的存储位置，程序结束后操作系统回收

Ⅴ.程序代码区(code)：存放函数体的二进制代码

下面我们给出一段代码进行一下简单的验证：

int g_a;//全局变量
int g_b;
static int s_g_a;//静态全局变量
static int s_g_b;
const int c_g_a=1;//全局常量
const int c_g_b=1;
const static int c_s_g_a;//静态全局常量
const static int c_s_g_b;
int main() {
	cout << "全局变量" << endl;
	cout << &g_a << endl;
	cout << &g_b << endl;
	cout << "静态全局变量" << endl;
	cout << &s_g_a << endl;
	cout << &s_g_b << endl;
	cout << "全局常量" << endl;
	cout << &c_g_a << endl;
	cout << &c_g_b << endl;
	cout << "静态全局常量" << endl;
	cout << &c_s_g_a << endl;
	cout << &c_s_g_b << endl;

	int l_a;//局部变量
	int l_b;
	cout << "局部变量" << endl;
	cout << &l_a << endl;
	cout << &l_b << endl;
	const int c_l_a=1;//局部常量
	const int c_l_b=1;
	cout << "局部常量" << endl;
	cout << &c_l_a << endl;
	cout << &c_l_b << endl;
	static int s_l_a;//静态局部变量
	static int s_l_b;
	cout << "静态局部变量" << endl;
	cout << &s_l_a << endl;
	cout << &s_l_b << endl;
	const static int c_s_l_a;//静态局部常量
	const static int c_s_l_b;
	cout << "静态局部常量" << endl;
	cout << &c_s_l_a << endl;
	cout << &c_s_l_b << endl;
	//字面量(字符串常量)
	cout << "字面量地址：" << &("123") << endl;
	return 0;
}

从中，我们不难发现，本次运行时，全局区的数据全部在00007FF69DC5开头的内存地址处，并且静态区的也是放在了这段内存中，而且：变量在+F1+段，常量在+BB+段。另外不被const修饰的普通常量(字符串字面量)的地址也存在了00007FF69DC5这段内存中，且在+C010处。综上分析，我们可以知道：大致就是这么一个分布。

Linux系统由操作系统预留空间，一般默认8M，Windows系统由编译器预留空间，其中VC++一般默认1M。当我们使用栈区空间时，都是比较节俭的，所以我们程序员一般会主动向堆区申请空间，以免栈溢出。

如果把内存分为四个区的话，一般不包括常量区。而其它四区的建立流程是：

流程说明：操作系统把物理硬盘代码load到内存=>操作系统把c代码分成四个区=>操作系统找到main函数入口执行。

二、函数调用模型

C语言的函数-CSDN博客

在上面将函数的时候我们提过函数栈帧的概念。那么这就是函数调用的模型。学好之后对函数的递归学习有很大帮助哦。

1、一个主程序有n个函数组成，C++编译器会建立有几个堆区？有几个堆区？

2、函数嵌套调用时，实参地址传给形参后，C++编译器如何管理变量的生命周期？

分析：通过函数fa()，调用函数fb()，通过参数传递的变量，内存空间能用嘛？

三、内存管理

在前文的内存知识章节我们只说了内存函数，没有说内存管理函数。对于C语言，内存管理函数包括：malloc，realloc，calloc，以及free四个。包含在头文件<stdlib.h>中。

1.malloc()函数

用处：申请堆区空间

函数原型：void* malloc(size_t _Size)

函数解析：参数是需要申请的空间字节大小，返回值是void*类型的指针，方便类型转换为其他类型的指针。

使用例子：

int *p=(int*)malloc(sizeof(int)*5);//申请能存放五个int类型数据的空间
//相当于一个存在于堆区的数组int [5]，但不是。

2.realloc()函数

用处：申请的空间不足，需要扩容

函数原型：void* realloc(void *_Block,size_t _Size)

函数解析：void*的用处全都是方便类型转换，_Size是字节大小。_Block是需要扩容的指针

使用例子：

int * p=(int*)malloc(sizeof(int)*4);
for(int i=0;i<4;i++){
    p[i]=i;
}
//此时我想对p[4]进行赋值，明显已经越界了，那我就扩容
p = (int*)realloc(p,sizeof(int)*8);
p[4]=15;

3.calloc()函数

用处：开辟空间的同时，赋予一定数量的内存一个初始默认值

函数原型：void* calloc(size_t _Count,size_t _Size)

函数解析：类似于malloc，不过参数多了一个_Count,这个参数的意思是，在申请空间的同时，为前Count块内存赋予初始默认值。

使用例子：

int n;cin>>n;//准备开辟多少 个 空间。
int *p=(int*)calloc(n,sizeof(int)*n);//个数*每个所占字节＝总字节
for(int i=0;i<n;i++){
    cout<<p[i]<<" ";
}

4.free()函数

用处：释放申请的堆区空间

函数原型：void free(void* _Block)

函数解释：将_Block指向的堆区空间进行释放。

使用例子：

free(p);//p为上面申请的指针的任意一个

初识new与delete

C++中的new运算符和delete运算符用于在堆上动态分配和释放内存。堆上的内存由程序员手动管理，可以在程序的任意位置进行分配和释放。

new运算符的语法如下：

new type;
new type[size];

其中，type可以是任意的数据类型，size是一个整数，表示要分配的数组大小。

new运算符会在堆上分配一块内存，并返回一个指向该内存的指针。如果分配成功，new运算符将返回一个指向type的指针；如果分配失败，new运算符将抛出std::bad_alloc异常。

例如，下面的代码分配了一个int数组：

int* arr = new int[10];

delete运算符的语法如下：

delete ptr;
delete[] ptr;

其中，ptr是由new运算符返回的指针。

delete运算符会释放ptr指向的内存，并调用析构函数来销毁对象（如果有的话）。如果ptr为nullptr，则delete运算符不会进行任何操作。

如果ptr是由new[]运算符返回的指针，则必须使用delete[]运算符来释放内存。如果使用delete运算符来释放由new[]分配的内存，行为是未定义的。

例如，下面的代码释放了前面分配的int数组：

delete[] arr;

需要注意的是，使用new运算符分配的内存必须使用delete运算符来释放，否则就会出现内存泄漏。同样地，使用new[]运算符分配的数组必须使用delete[]运算符来释放。

另外，还可以使用placement new运算符在已经分配的内存上构造对象，以及使用delete运算符销毁对象并释放内存。但这种用法相对较少见，一般只在特定场景下使用。

下面是一个完整的示例，展示了如何使用new与delete运算符：

#include <iostream> 
class MyClass { 
public: 
    MyClass(int val) : value(val) { 
        std::cout << "Constructor called: " << value << std::endl; 
    }
    ~MyClass() {
        std::cout << "Destructor called: " << value << std::endl; 
    } 
private: 
    int value; 
}; 
int main() { 
    // 动态分配单个对象 
    MyClass* obj = new MyClass(10); 
    // 动态分配数组 
    MyClass* arr = new MyClass[3] { MyClass(1), MyClass(2), MyClass(3) }; 
    // 释放单个对象 
    delete obj; 
    // 释放数组 
    delete[] arr; 
    return 0; 
}

在这个示例中，我们定义了一个简单的类MyClass，并展示了如何使用new运算符分配内存和delete运算符释放内存。

剖析new与delete

（本段内容为转载：深入理解C++ new/delete, new []/delete[]动态内存管理 - tp_16b - 博客园）

在C语言中，我们写程序时，总是会有动态开辟内存的需求，每到这个时候我们就会想到用malloc/free 去从堆里面动态申请出来一段内存给我们用。但对这一块申请出来的内存，往往还需要我们对它进行稍许的“加工”后即初始化 才能为我们所用，虽然C语言为我们提供了calloc来开辟一段初始化好（0）的一段内存，但面对象中各是各样的数据成员初始化，它同样束手无策。同时，为了保持良好的编程习惯，我们也都应该对申请出来的内存作手动进行初始化。

对此，这常常让我们感到一丝繁琐，于是到了C++中就有了new/delete, new []/delete[] 。用它们便可实现动态的内存管理。

在C++中，把int 、char..等内置类型的变量也看作对象，它们也是存在构造函数和析构函数的，只是通常对它们，系统调用了默认的构造函数来初始化以及默认的析构（编译器优化）。所以new int、new int(3)看起来和普通的定义好像没什么区别。但对于自定义类型的对象，此种方式在创建对象的同时，还会将对象初始化好；于是new/delete、new []/delete []方式管理内存相对于malloc/free的方式管理的优势就体现出来了，因为它们能保证对象一被创建出来便被初始化，出了作用域便被自动清理。

　　*  malloc/free只是动态分配内存空间/释放空间。而new/delete除了分配空间还会调用构造函数和析构函数进行初始化与清理（清理成员）。

　　*  它们都是动态管理内存的入口。
　　* malloc/free是C/C++标准库的函数，new/delete是C++操作符。
　　*  malloc/free需要手动计算类型大小且返回值w为void*，new/delete可自动计算类型的大小，返回对应类型的指针。

　　*  malloc/free管理内存失败会返回0，new/delete等的方式管理内存失败会抛出异常。