乐趣区

关于c:看完这篇你还能不懂C语言C内存管理

jiezi

起源：公众号（c 语言与 cpp 编程）

C 语言内存治理指对系统内存的调配、创立、应用这一系列操作。在内存治理中，因为是操作系统内存，使用不当会造成毕竟麻烦的后果。本文将从零碎内存的调配、创立登程，并且应用例子来举例说明内存治理不当会呈现的状况及解决办法。

一、内存

在计算机中，每个应用程序之间的内存是互相独立的，通常状况下应用程序 A 并不能拜访应用程序 B，当然一些非凡技巧能够拜访，但此文并不具体进行阐明。例如在计算机中，一个视频播放程序与一个浏览器程序，它们的内存并不能拜访，每个程序所领有的内存是分区进行治理的。

在计算机系统中，运行程序 A 将会在内存中开拓程序 A 的内存区域 1，运行程序 B 将会在内存中开拓程序 B 的内存区域 2，内存区域 1 与内存区域 2 之间逻辑分隔。

1.1 内存四区

在程序 A 开拓的内存区域 1 会被分为几个区域，这就是 内存四区，内存四辨别为栈区、堆区、数据区与代码区。

栈区指的是存储一些长期变量的区域，长期变量包含了局部变量、返回值、参数、返回地址等，当这些变量超出了以后作用域时将会自动弹出。该栈的最大存储是有大小的，该值固定，超过该大小将会造成栈溢出。

堆区指的是一个比拟大的内存空间，次要用于对动态内存的调配；在程序开发中个别是开发人员进行调配与开释，若在程序完结时都未开释，零碎将会主动进行回收。

数据区指的是次要寄存全局变量、常量和动态变量的区域，数据区又能够进行划分，分为全局区与动态区。全局变量与动态变量将会寄存至该区域。

代码区就比拟好了解了，次要是存储可执行代码，该区域的属性是只读的。

1.2 应用代码证实内存四区的底层构造

因为栈区与堆区的底层构造比拟直观的体现，在此应用代码只演示这两个概念。首先查看代码察看栈区的内存地址分配情况：

include<stdio.h>

int main()

{

int a = 0;

int b = 0;

char c=’0′;

printf(“ 变量 a 的地址是：%dn 变量 b 的地址是：%dn 变量 c 的地址是：%dn”, &a, &b, &c);

}

运行后果为：

咱们能够察看到变量 a 的地址是 2293324 变量 b 的地址是 2293320，因为 int 的数据大小为 4 所以两者之间距离为 4；再查看变量 c，咱们发现变量 c 的地址为 2293319，与变量 b 的地址 2293324 距离 1，因为 c 的数据类型为 char，类型大小为 1。在此咱们察看发现，明明我创立变量的时候程序是 a 到 b 再到 c，为什么它们之间的地址不是减少而是缩小呢？那是因为栈区的一种数据存储构造为先进后出，如图：

首先栈的顶部为地址的“最小”索引，随后往下顺次增大，然而因为堆栈的非凡存储构造，咱们将变量 a 先进行存储，那么它的一个索引地址将会是最大的，随后顺次缩小；第二次存储的值是 b，该值的地址索引比 a 小，因为 int 的数据大小为 4，所以在 a 地址为 2293324 的根底上往上缩小 4 为 2293320，在存储 c 的时候为 char，大小为 1，则地址为 2293319。因为 a、b、c 三个变量同属于一个栈内，所以它们地址的索引是连续性的，那如果我创立一个动态变量将会如何？在以上内容中阐明了动态变量存储在动态区内，咱们当初就来证实一下：

include<stdio.h>

int main()

{

int a = 0;

int b = 0;

char c=’0′;

static int d = 0;

printf(“ 变量 a 的地址是：%dn 变量 b 的地址是：%dn 变量 c 的地址是：%dn”, &a, &b, &c);

printf(“ 动态变量 d 的地址是：%dn”, &d);

}

运行后果如下：

以上代码中创立了一个变量 d，变量 d 为动态变量，运行代码后从后果上得悉，动态变量 d 的地址与个别变量 a、b、c 的地址并不存在间断，他们两个的内存地址是离开的。那接下来在此建一个全局变量，通过上述内容得悉，全局变量与动态变量都应该存储在动态区，代码如下：

include<stdio.h>

int e = 0;

int main()

{

int a = 0;

int b = 0;

char c=’0′;

static int d = 0;

printf(“ 变量 a 的地址是：%dn 变量 b 的地址是：%dn 变量 c 的地址是：%dn”, &a, &b, &c);

printf(“ 动态变量 d 的地址是：%dn”, &d);

printf(“ 全局变量 e 的地址是：%dn”, &e);

}

运行后果如下：

从以上运行后果中证实了上述内容的真实性，并且也失去了一个知识点，栈区、数据区都是应用栈构造对数据进行存储。

在以上内容中还阐明了一点栈的个性，就是容量具备固定大小，超过最大容量将会造成栈溢出。查看如下代码：

include<stdio.h>

int main()

{

char arr_char[1024*1000000];

arr_char[0] = ‘0’;

}

以上代码定义了一个字符数组 arr_char，并且设置了大小为 1024*1000000，设置该数据是不便查看大小；随后在数组头部进行赋值。运行后果如下：

这是程序运行出错，起因是造成了栈的溢出。在平时开发中若须要大容量的内存，须要应用堆。

堆并没有栈一样的构造，也没有栈一样的先进后出。须要人为的对内存进行调配应用。代码如下：

include<stdio.h>

include<string.h>

include <malloc.h>

int main()

{

char p1 = (char )malloc(1024*1000000);

strcpy(p1, “ 这里是堆区 ”);

printf(“%sn”, p1);

}

以上代码中应用了 strcpy 往手动开拓的内存空间 p1 中传数据“这里是堆区”，手动开拓空间应用 malloc，传入申请开拓的空间大小 1024*1000000，在栈中那么大的空间必定会造成栈溢出，而堆自身就是大容量，则不会呈现该状况。随后输入开拓的内存中内容，运行后果如下：

在此要留神 p1 是示意开拓的内存空间地址。

二、malloc 和 free

在 C 语言（不是 C++)中，malloc 和 free 是零碎提供的函数，成对应用，用于从堆中调配和开释内存。malloc 的全称是 memory allocation 译为“动态内存调配”。

2.1 malloc 和 free 的应用

在开拓堆空间时咱们应用的函数为 malloc，malloc 在 C 语言中是用于申请内存空间，malloc 函数的原型如下：

void *malloc(size_t size);

在 malloc 函数中，size 是示意须要申请的内存空间大小，申请胜利将会返回该内存空间的地址；申请失败则会返回 NULL，并且申请胜利也不会主动进行初始化。

仔细的同学可能会发现，该函数的返回值阐明为 void ，在这里 void 并不指代某一种特定的类型，而是阐明该类型不确定，通过接管的指针变量从而进行类型的转换。在分配内存时须要留神，即时在程序敞开时零碎会主动回收该手动申请的内存，但也要进行手动的开释，保障内存可能在不须要时返回至堆空间，使内存可能正当的调配应用。

开释空间应用 free 函数，函数原型如下：

void free(void *ptr);

free 函数的返回值为 void，没有返回值，接管的参数为应用 malloc 调配的内存空间指针。一个残缺的堆内存申请与开释的例子如下：

include<stdio.h>

include<string.h>

include <malloc.h>

int main() {

int n, *p, i;

printf(“ 请输出一个任意长度的数字来调配空间:”);

scanf(“%d”, &n);

p = (int )malloc(n sizeof(int));

if(p==NULL){

printf(“ 申请失败 n ”);

return 0;

}else{

printf(“ 申请胜利 n ”);

}

memset(p, 0, n * sizeof(int));// 填充 0

// 查看

for (i = 0; i < n; i++)

printf(“%d “, p[i]);

printf(“n”);

free(p);

p = NULL;

return 0;

}

以上代码中应用了 malloc 创立了一个由用户输出创立指定大小的内存，判断了内存地址是否创立胜利，且应用了 memset 函数对该内存空间进行了填充值，随后应用 for 循环进行了查看。最初应用了 free 开释了内存，并且将 p 赋值 NULL，这点须要次要，不能使指针指向未知的地址，要置于 NULL；否则在之后的开发者会误以为是个失常的指针，就有可能再通过指针去拜访一些操作，然而在这时该指针曾经无用，指向的内存也不知此时被如何应用，这时若出现意外将会造成无奈预估的结果，甚至导致系统解体，在 malloc 的应用中更须要须要。

2.2 内存透露与平安应用实例与解说

内存透露是指在动态分配的内存中，并没有开释内存或者一些起因造成了内存无奈开释，轻度则造成零碎的内存资源节约，重大的导致整个零碎解体等状况的产生。

内存透露通常比拟荫蔽，且大量的内存透露产生不肯定会产生无奈接受的结果，但因为该谬误的积攒将会造成整体零碎的性能降落或零碎解体。特地是在较为大型的零碎中，如何无效的避免内存透露等问题的呈现变得尤为重要。例如一些长时间的程序，若在运行之初有大量的内存透露的问题产生可能并未出现，但随着运行工夫的增长、零碎业务解决的减少将会累积呈现内存透露这种状况；这时极大的会造成不可预知的结果，如整个零碎的解体，造成的损失将会难以承受。由此避免内存透露对于底层开发人员来说尤为重要。

C 程序员在开发过程中，不可避免的面对内存操作的问题，特地是频繁的申请动态内存时会及其容易造成内存透露事变的产生。如申请了一块内存空间后，未初始化便读其中的内容、间接申请动态内存但并没有进行开释、开释完一块动静申请的内存后持续援用该内存内容；如上所述这种问题都是呈现内存透露的起因，往往这些起因因为过于荫蔽在测试时不肯定会齐全分明，将会导致在我的项目上线后的长时间运行下，导致灾难性的结果产生。

如下是一个在子函数中进行了内存空间的申请，然而并未对其进行开释：

include<stdio.h>

include<string.h>

include <malloc.h>

void m() {

char *p1;

p1 = malloc(100);

printf(“ 开始对内存进行透露 …”);

}

int main() {

m();

return 0;

}

如上代码中，应用 malloc 申请了 100 个单位的内存空间后，并没有进行开释。假如该 m 函数在以后零碎中调用频繁，那将会每次应用都将会造成 100 个单位的内存空间不会开释，长此以往就会造成重大的结果。理当在 p1 应用结束后增加 free 进行开释：

free(p1);

以下示范一个读取文件时不标准的操作：

include<stdio.h>

include<string.h>

include <malloc.h>

int m(char *filename) {

FILE* f;

int key;

f = fopen(filename, “r”);

fscanf(f, “%d”, &key);

return key;

}

int main() {

m(“number.txt”);

return 0;

}

以上文件在读取时并没有进行 fclose，这时将会产生多余的内存，可能一次还好，屡次会减少成倍的内存，能够应用循环进行调用，之后在工作管理器中可查看该程序运行时所占的内存大小，代码为：

include<stdio.h>

include<string.h>

include <malloc.h>

int m(char *filename) {

FILE* f;

int key;

f = fopen(filename, “r”);

fscanf(f, “%d”, &key);

return key;

}

int main() {

int i;

for(i=0;i<500;i++) {

m(“number.txt”);

}

return 0;

}

可查看增加循环后的程序与增加循环前的程序做内存占用的比照，就能够发现两者之间增加了循环的代码将会成本增加占用容量。

未被初始化的指针也会有可能造成内存透露的状况，因为指针未初始化所指向不可控，如：

int *p;

*p = val;

包含谬误的开释内存空间：

pp=p;

free(p);

free(pp);

开释后应用，产生悬空指针。在申请了动态内存后，应用指针指向了该内存，应用结束后咱们通过 free 函数开释了申请的内存，该内存将会容许其它程序进行申请；然而咱们应用过后的动态内存指针仍旧指向着该地址，假如其它程序下一秒申请了该区域内的内存地址，并且进行了操作。当我仍旧应用已 free 开释后的指针进行下一步的操作时，或者所进行了一个计算，那么将会造成的后果天差地别，或者是其它灾难性结果。所以对于这些指针在生存期完结之后也要置为 null。查看一个示例，因为 free 开释后仍旧应用该指针，造成的计算结果天差地别：

include<stdio.h>

include<string.h>

include <malloc.h>

int m(char *freep) {

int val=freep[0];

printf(“2freep=:%dn”,val2);

free(freep);

val=freep[0];

printf(“2freep=:%dn”,val2);

}

int main() {

int freep = (int ) malloc(sizeof (int));

freep[0]=1;

m(freep);

return 0;

}

以上代码应用 malloc 申请了一个内存后，传值为 1；在函数中首先应用 val 值接管 freep 的值，将 val 乘 2，之后开释 free，从新赋值给 val，最初应用 val 再次乘 2，此时造成的后果呈现了极大的扭转，而且最恐怖的是该谬误很难发现，隐蔽性很强，然而造成的后顾难以承受。运行后果如下：

三、new 和 delete

C++ 中应用 new 和 delete 从堆中调配和开释内存，new 和 delete 是运算符，不是函数，两者成对应用(前面阐明为什么成对应用)。

new/delete 除了分配内存和开释内存（与 malloc/free），还做更多的事件，所有在 C++ 中不再应用 malloc/free 而应用 new/delete。

3.1 new 和 delete 应用

new 个别应用格局如下：

  • 指针变量名 = new 类型标识符;
  • 指针变量名 = new 类型标识符(初始值);
  • 指针变量名 = new 类型标识符[内存单元个数];

在 C ++ 中 new 的三种用法包含：plain new，nothrow new 和 placement new。

plain new 就是咱们最常应用的 new 的形式，在 C++ 中的定义如下：

void* operator new(std::size_t) throw(std::bad_alloc);

void operator delete(void *) throw();

plain new 在调配失败的状况下，抛出异样 std::bad_alloc 而不是返回 NULL，因而通过判断返回值是否为 NULL 是徒劳的。

char *getMemory(unsigned long size)

{

char * p = new char[size];

return p;

}

void main(void)

{

try{

char * p = getMemory(1000000); // 可能产生异样

// …

delete [] p;

}

catch(const std::bad_alloc & ex)

{

cout << ex.what();

}

}

nothrow new 是不抛出异样的运算符 new 的模式。nothrow new 在失败时，返回 NULL。定义如下：

void * operator new(std::size_t, const std::nothrow_t&) throw();

void operator delete(void*) throw();

void func(unsinged long length)

{

unsinged char * p = new(nothrow) unsinged char[length];

// 在应用这种 new 时要加(nothrow)，示意不应用异样解决。

if (p == NULL) // 不抛异样，肯定要查看

cout << “allocte failed !”;

// …

delete [] p;

}

placement new 意即“搁置”，这种 new 容许在一块曾经调配胜利的内存上从新结构对象或对象数组。placement new 不必放心内存调配失败，因为它基本不分配内存，它做的惟一一件事件就是调用对象的构造函数。定义如下：

void operator new(size_t, void);

void operator delete(void, void);

palcement new 的主要用途就是重复应用一块较大的动态分配的内存来结构不同类型的对象或者他们的数组。placement new 结构起来的对象或其数组，要显示的调用他们的析构函数来销毁，千万不要应用 delete。

void main()

{

using namespace std;

char * p = new(nothrow) char [4];

if (p == NULL)

{

cout << “allocte failed” << endl;

exit(-1);

}

// …

long * q = new (p) long(1000);

delete []p; // 只开释 p，不要用 q 开释。

}

p 和 q 仅仅是首址雷同，所构建的对象能够类型不同。所“搁置”的空间应小于原空间，以防不测。当”搁置 new”超过了申请的范畴，Debug 版下会解体，但 Release 能运行而不会呈现解体！

该运算符的作用是：只有第一次调配胜利，不再放心调配失败。

void main()

{

using namespace std;

char * p = new(nothrow) char [100];

if (p == NULL)

{

cout << “allocte failed” << endl;

exit(-1);

}

long * q1 = new (p) long(100);

// 应用 q1 …

int * q2 = new (p) int[100/sizeof(int)];

// 应用 q2 …

ADT * q3 = new (p) ADT[100/sizeof(ADT)];

// 应用 q3 而后开释对象 …

delete [] p; // 只开释空间，不再析构对象。

}

留神：应用该运算符结构的对象或数组，肯定要显式调用析构函数，不可用 delete 代替析构，因为 placement new 的对象的大小不再与原空间雷同。

void main()

{

using namespace std;

char * p = new(nothrow) char [sizeof(ADT)+2];

if (p == NULL)

{

cout << “allocte failed” << endl;

exit(-1);

}

// …

ADT * q = new (p) ADT;

// …

// delete q; // 谬误

q->ADT::~ADT(); // 显式调用析构函数，仅开释对象

delete [] p; // 最初，再用原指针来开释内存

}

placement new 的主要用途就是能够重复应用一块已申请胜利的内存空间。这样能够防止申请失败的徒劳，又能够防止应用后的开释。

特地要留神的是对于 placement new 绝不能够调用的 delete, 因为该 new 只是应用他人替它申请的中央。开释内存是 nothrow new 的事，即要应用原来的指针开释内存。free/delete 不要反复调用，被零碎立刻回收后再利用，再一次 free/delete 很可能把不是本人的内存开释掉，导致异样甚至解体。

下面提到 new/delete 比 malloc/free 多做了一些事件，new 绝对于 malloc 会额定的做一些初始化工作，delete 绝对于 free 多做一些清理工作。

class A

{

public:

A()

{

cont<<“A()构造函数被调用 ”<<endl;

}

~A()

{

cont<<“~A()构造函数被调用 ”<<endl;

}

}

在 main 主函数中，退出如下代码：

A* pa = new A(); // 类 A 的构造函数被调用

delete pa; // 类 A 的析构函数被调用

能够看出：应用 new 生成一个类对象时零碎会调用该类的构造函数，应用 delete 删除一个类对象时，零碎会调用该类的析构函数。能够调用构造函数 / 析构函数就意味着 new 和 delete 具备针对堆所调配的内存进行初始化和开释的能力，而 malloc 和 free 不具备。

2.2 delete 与 delete[] 的区别

c++ 中对 new 申请的内存的开释形式有 delete 和 delete[] 两种形式，到底这两者有什么区别呢？

咱们通常从教科书上看到这样的阐明：

  • delete 开释 new 调配的单个对象指针指向的内存
  • delete[] 开释 new 调配的对象数组指针指向的内存 那么，依照教科书的了解，咱们看下上面的代码：

int *a = new int[10];

delete a; // 形式 1

delete[] a; // 形式 2

  1. 针对简略类型 应用 new 调配后的不论是数组还是非数组模式内存空间用两种形式均可 如：

int *a = new int[10];

delete a;

delete[] a;

此种状况中的开释成果雷同，起因在于：调配简略类型内存时，内存大小曾经确定，零碎能够记忆并且进行治理，在析构时，零碎并不会调用析构函数。

它间接通过指针能够获取理论调配的内存空间，哪怕是一个数组内存空间(在调配过程中 零碎会记录分配内存的大小等信息，此信息保留在构造体 _CrtMemBlockHeader 中，具体情况可参看 VC 装置目录下 CRTSRCDBGDEL.cpp)。

  1. 针对类 Class，两种形式体现出具体差别

当你通过下列形式调配一个类对象数组：

class A

{

private:

char *m_cBuffer;

int m_nLen;

“ public:

A(){ m_cBuffer = new char[m_nLen]; }

~A() { delete [] m_cBuffer; }

};

A *a = new A[10];

delete a; // 仅开释了 a 指针指向的全副内存空间 然而只调用了 a[0]对象的析构函数 剩下的从 a[1]到 a[9]这 9 个用户自行调配的 m_cBuffer 对应内存空间将不能开释 从而造成内存透露

delete[] a; // 调用应用类对象的析构函数开释用户本人分配内存空间并且 开释了 a 指针指向的全副内存空间

所以总结下就是，如果 ptr 代表一个用 new 申请的内存返回的内存空间地址，即所谓的指针，那么：

delete ptr  代表用来开释内存，且只用来开释 ptr 指向的内存。delete[] rg   用来开释 rg 指向的内存，！！还逐个调用数组中每个对象的 destructor！！

对于像 int/char/long/int*/struct 等等简略数据类型，因为对象没有 destructor，所以用 delete 和 delete []是一样的！然而如果是 C++ 对象数组就不同了！

对于 new[] 和 delete[]，其中又分为两种状况：

  • (1) 为根本数据类型调配和回收空间；
  • (2) 为自定义类型调配和回收空间；

对于 (1)，下面提供的程序曾经证实了 delete[] 和 delete 是等同的。然而对于 (2)，状况就产生了变动。

咱们来看上面的例子，通过例子的学习理解 C++ 中的 delete 和 delete[] 的应用办法

include <iostream>

using namespace std;

class Babe

{

public:

Babe()

{

cout << “Create a Babe to talk with me” << endl;

}

~Babe()

{

cout << “Babe don’t Go away,listen to me” << endl;

}

};

int main()

{

Babe* pbabe = new Babe[3];

delete pbabe;

pbabe = new Babe[3];

delete[] pbabe;

return 0;

}

后果是:

Create a babe to talk with me

Create a babe to talk with me

Create a babe to talk with me

Babe don’t go away,listen to me

Create a babe to talk with me

Create a babe to talk with me

Create a babe to talk with me

Babe don’t go away,listen to me

Babe don’t go away,listen to me

Babe don’t go away,listen to me

大家都看到了，只应用 delete 的时候只呈现一个 Babe don’t go away,listen to me，而应用 delete[] 的时候呈现 3 个 Babe don’t go away,listen to me。不过不论应用 delete 还是 delete[] 那三个对象的在内存中都被删除，既存储地位都标记为可写，然而应用 delete 的时候只调用了 pbabe[0] 的析构函数，而应用了 delete[] 则调用了 3 个 Babe 对象的析构函数。

你肯定会问，反正不管怎样都是把存储空间开释了，有什么区别。

答：关键在于调用析构函数上。此程序的类没有应用操作系统的系统资源（比方：Socket、File、Thread 等），所以不会造成显著恶果。如果你的类应用了操作系统资源，单纯把类的对象从内存中删除是不得当的，因为没有调用对象的析构函数会导致系统资源不被开释，这些资源的开释必须依附这些类的析构函数。所以，在用这些类生成对象数组的时候，用 delete[] 来开释它们才是王道。而用 delete 来开释兴许不会出问题，兴许结果很重大，具体要看类的代码了。

最初祝各位保持良好的代码编写标准升高严重错误的产生。

退出移动版