更多精彩内容.....

🎉❤️播主の主页✨😘

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*类型的指针，方便类型转换为其他类型的指针。

使用例子：

<code>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等的方式管理内存失败会抛出异常。

---

四、常见内存错误

1.内存泄露

概念：内存泄漏（Memory Leak）是指程序在运行过程中，未能释放已经分配的内存空间，从而导致可用内存减少的现象。随着时间的推移，内存泄漏会导致系统性能下降，甚至可能导致程序崩溃。

内存泄漏一般发生在以下情况下：

动态分配内存但未释放：使用如<code>malloc/new（在C/C++中）申请内存后，如果没有相应的free/delete 调用便不会释放这块内存。

引用计数错误：在使用引用计数管理内存的情况下，如果对象之间形成循环引用，可能导致对象的内存无法释放。

不适当地存储指针：程序在某个数据结构中存储了对动态分配内存的指针，但在不再需要该数据结构时，没有释放内存。

为防止内存泄漏，开发者可以采取以下措施：

使用智能指针（在C++中，可自动管理内存）。定期检查和分析代码，寻找潜在的内存泄漏。使用内存检测工具（如Valgrind等），识别和报告内存泄漏问题。确保在不再需要对象时适时释放内存。

总结：申请的内存空间没有被释放掉。及时发现和修复内存泄漏问题，可以提高程序的稳定性和性能。

2.栈溢出

概念：栈溢出（Stack Overflow）是一种运行时错误，发生在程序使用的栈空间超过了栈所分配的大小时。栈是用于存储局部变量和函数调用信息的一块内存区域，每当一个函数被调用时，相关的局部变量和返回地址等信息会被压入栈中；当函数执行完毕时，这些信息会被弹出栈外。

栈溢出的常见原因包括：

深度递归：当一个函数递归调用自身且没有适当的终止条件时，可能导致栈帧不断增加，最终消耗完分配给栈的内存。

过大的局部变量：在函数中声明过大的数组或数据结构，也可能导致栈空间不够。

无限循环或错误的循环逻辑：在某些情况下，如果循环体中的函数调用未能适当退出，也可能引发栈溢出。

栈溢出会导致程序崩溃，通常会触发操作系统的保护机制，从而抛出异常或错误信息。为防止栈溢出，可以采取以下措施：

避免不必要的深度递归：使用迭代法替代递归，或者优化递归算法以减少栈深度。

合理使用局部变量：尽量避免在栈上使用过大的数据结构，考虑使用堆分配（如动态分配内存）。

监测和调试用：使用调试工具跟踪栈的使用情况，识别潜在的栈溢出风险。

控制递归深度：合理设计递归的深度和适当的退出条件。

总结：存在栈区的数组开辟太大，递归层次太深。有效减少栈溢出的发生，确保程序的稳定性和可靠性。

3.越界访问与野指针

越界访问：在数组或存储块的边界之外进行读或写操作。可能导致数据损坏或安全漏洞。

野指针：访问未初始化的指针会导致不可预测的行为，因为它指向未知的内存区域。

4.双重释放与悬挂指针

悬挂指针：指向已经释放的内存地址的指针。使用这种指针进行访问会导致未定义行为。悬挂指针通常是在调用delete或free后未将指针置为nullptr导致的。

双重释放：指同一块内存被delete或free多次释放，这会导致未定义行为，甚至程序崩溃。

5.其他情况

其它情况还包括：使用new而不配对delete，使用malloc而不配对free，或者使用new开辟多块空间没有使用delete[]。

不当使用智能指针：虽然智能指针（如std::unique_ptr和std::shared_ptr）可以帮助管理内存，但不正确的使用仍然可能导致悬挂指针、循环引用（在std::shared_ptr中）等问题。

---

感谢大家。