必知必会-C语言内存管理

内存管理

衡量是否掌握C语言的两个标准，一：指针；二：内存管理。

指针的相关内容欢迎查看历史文章，本文会介绍C语言内存管理的相关知识，其对于读者之后的编程生涯也会大有裨益。

如果你有相关需求，就往下看吧。

一.栈、堆和静态区

对于程序员，一般来说，我们可以简单的理解为内存分为三个部分：静态区，栈，堆。

很多书没有把把堆和栈解释清楚，导致初学者总是分不清楚。

其实堆栈就是栈，而不是堆。

堆的英文是 heap；栈的英文是 stack，也翻译为堆栈。

堆和栈都有自己的特性，这里先不做讨论。

再打个比方：一层教学楼，可能有外语教室，允许外语系学生和老师进入；还可能有数学教师，允许数学系学生和老师进入；还可能有校长办公室，允许校长进入。

同样，内存也是这样，内存的三个部分，不是所有的东西都能存进去的。

• 静态区：保存自动全局变量和 static 变量（包括 static 全局和局部变量）。
  

  
  

  静态区的内容在整个程序的生命周期内都存在，由编译器在编译的时候分配。
  

  
  

• 栈：保存局部变量。
  

  
  

  栈上的内容只在函数的范围内存在，当函数运行结束，这些内容也会自动被销毁。
  

  
  

  其特点是效率高，但空间大小有限。
  

  
  

• 堆：由 malloc 系列函数或 new *** 作符分配的内存。
  

  
  

  其生命周期由 free 或 delete 决定。
  

  
  

  在没有释放之前一直存在，直到程序结束。
  

  
  

  其特点是使用灵活，空间比较大，但容易出错

二.常见的内存错误及对策 2.1指针没有指向一块合法的内存 1.结构体成员指针未初始化

struct student
{
	char *name;
	int score;
}stu,*pstu;

int main()
{
	strcpy(stu.name,"Jimy");
    stu.score = 99;
    return 0;
}

很多初学者犯了这个错误还不知道是怎么回事。

这里定义了结构体变量 stu，但是他没想到这个结构体内部 char *name 这成员在定义结构体变量stu时，只是给 name 这个指针变量本身分配了 4 个字节。

name 指针并没有指向一个合法的地址，这时候其内部存的只是一些乱码。

所以在调用 strcpy 函数时，会将字符串"Jimy"往乱码所指的内存上拷贝，而这块内存 name 指针根本就无权访问，导致出错。

解决的办法是为 name 指针 malloc 一块空间。

同样，也有人犯如下错误：

int main()
{
	pstu = (struct student*)malloc(sizeof(struct student));
	strcpy(pstu->name,"Jimy");
	pstu->score = 99;
	free(pstu);
    return 0;
}

为指针变量 pstu 分配了内存，但是同样没有给 name 指针分配内存。

错误与上面第一种情况一样，解决的办法也一样。

这里用了一个 malloc 给人一种错觉，以为也给name指针分配了内存。

2.没有为结构体指针分配足够的内存

int main()
{
  pstu = (struct student*)malloc(sizeof(struct student*));
  strcpy(pstu->name,"Jimy");
  pstu->score = 99;
  free(pstu);
  return 0;
}

为 pstu 分配内存的时候，分配的内存大小不合适。

这里把 sizeof(struct student)误写为sizeof(struct student*)

3.函数的入口校验

不管什么时候，我们使用指针之前一定要确保指针是有效的。

一般在函数入口处使用 assert(NULL != p)对参数进行校验。

在非参数的地方使用if（NULL != p）来校验。

但这都有一个要求，即p在定义的同时被初始化为 NULL 了。

比如上面的例子，即使用 if（NULL != p）校验也起不了作用，因为name指针并没有被初始化为 NULL，其内部是一个非 NULL 的乱码。

assert 是一个宏，而不是函数，包含在assert.h头文件中。

如果其后面括号里的值为假，则程序终止运行，并提示出错；如果后面括号里的值为真，则继续运行后面的代码。

这个宏只在 Debug 版本上起作用，而在 Release 版本被编译器完全优化掉，这样就不会影响代码的性能。

有人也许会问，既然在 Release 版本被编译器完全优化掉，那 Release 版本是不是就完全没有这个参数入口校验了呢？这样的话那不就跟不使用它效果一样吗？是的，使用 assert 宏的地方在 Release 版本里面确实没有了这些校验。

但是我们要知道，assert 宏只是帮助我们调试代码用的，它的一切作用就是让我们尽可能的在调试函数的时候把错误排除掉，而不是等到 Release 之后。

它本身并没有除错功能。

再有一点就是，参数出现错误并非本函数有问题，而是调用者传过来的实参有问题。

assert 宏可以帮助我们定位错误，而不是排除错误。

2.2为指针分配的内存大小

为指针分配了内存，但是内存大小不够，导致出现越界错误。

char *p1 = “abcdefg”;
char *p2 = (char *)malloc(sizeof(char)*strlen(p1));
strcpy(p2,p1);

p1 是字符串常量，其长度为 7 个字符，但其所占内存大小为 8 个 byte。

初学者往往忘了字符串常量的结束标志“ p1”。

这样的话将导致“p2 ” 字符串中最后一个空字符char *p2 = (char *)malloc(sizeof(char)*strlen(p1)+1*sizeof(char));没有被拷贝到 char a[7] = {‘a’,’b’,’c’,’d’,’e’,’f’,’g’};中。

解决的办法是加上这个字符串结束标志符：

char

这里需要注意的是，只有字符串常量才有结束标志符。

比如下面这种写法就没有结束标志符了：

byte

另外，不要因为 sizeof（char） 类型大小为 1 个 int i = 10； char *p = (char *)malloc(sizeof(char))； 就省略int i = 0； char *p = NULL； 这种写法。

这样只会使你的代码可移植性下降。

2.3内存分配成功，但并未初始化

犯这个错误往往是由于没有初始化的概念或者是以为内存分配好之后其值自然为 0。

未初始化指针变量也许看起来不那么严重，但是它确确实实是个非常严重的问题，而且往往出现这种错误很难找到原因。

曾经在写一个 windows 程序时，想调用字库的某个字体。

而调用这个字库需要填充一个结构体他很自然的定义了一个结构体变量，然后把想要的字库代码赋值给了相关的变量。

但是，问题就来了，不管怎么调试，所需要的这种字体效果总是不出来。

于是单步调试。

在观察这个结构体变量的内存时，发现有几个成员的值为乱码。

就是其中某一个乱码惹得祸！因为系统会按照这个结构体中的某些特定成员的值去字库中寻找匹配的字体，当这些值与字库中某种字体的某些项匹配时，就调用这种字体。

但是很不幸，正是因为这几个乱码，导致没有找到相匹配的字体！因为系统并无法区分什么数据是乱码，什么数据是有效的数据。

只要有数据，系统就理所当然的认为它是有效的。

也许这种严重的问题并不多见，但是也绝不能掉以轻心。

所以在定义一个变量时，第一件事就是初始化。

你可以把它初始化为一个有效的值，比如:

int a[10] = {0};

但是往往这个时候我们还不确定这个变量的初值，这样的话可以初始化为 0 或 NULL。

memset

如果定义的是数组的话，可以这样初始化：

memset（a,0,sizeof(a)）;

或者用memset 函数来初始化为 0：

byte

memset 函数有三个参数，第一个是要被设置的内存起始地址；第二个参数是要被设置的值；第三个参数是要被设置的内存大小，单位为 if。

这里并不想过多的讨论 assert函数的用法，如果想了解更多，请参考相关资料。

至于指针变量如果未被初始化，会导致int a[10] = {0}; for (i=0; i<=10; i++) { a[i] = i; } 语句或for宏校验失败。

2.4内存越界

内存分配成功，且已经初始化，但是 *** 作越过了内存的边界。

这种错误经常是由于 *** 作数组或指针时出现“多 1”或“少 1”。

比如：

malloc 

所以，new 循环的循环变量一定要使用半开半闭的区间，而且如果不是特殊情况，循环变量尽量从 0 开始。

2.5内存泄漏

内存泄漏几乎是很难避免的，不管是老手还是新手，都存在这个问题。

甚至包括windows，Linux 这类软件，都或多或少有内存泄漏。

也许对于一般的应用软件来说，这个问题似乎不是那么突出，重启一下也不会造成太大损失。

但是如果你开发的是嵌入式系统软件呢？比如汽车制动系统，心脏起搏器等对安全要求非常高的系统。

你总不能让心脏起搏器重启吧。

会产生泄漏的内存就是堆上的内存（这里不讨论资源或句柄等泄漏情况），也就是说 free系列函数或 delete *** 作符分配的内存。

如果用完之后没有及时malloc 或

内存分配给谁？

，这块内存就无法释放，直到整个程序终止。

1.如何使用malloc函数

分配多大内存？

是一个函数，专门用来从堆上分配内存。

使用 malloc 函数需要几个要求：

• 是否还有足够内存分配？
• 内存的将用来存储什么格式的数据，即内存用来做什么?
• 分配好的内存在哪里？
malloc (void *) malloc(int size)

如果这五点都确定，那内存就能分配。

下面先看 malloc函数的原型：

void

int 函数的返回值是一个 malloc 类型的指针，参数为void *类型数据，即申请分配的内存大小，单位是 byte。

内存分配成功之后，char *p = (char *)malloc(100); 函数返回这块内存的首地址。

你需要一个指针来接收这个地址。

但是由于函数的返回值是 char *类型的，所以必须强制转换成你所接收的类型。

也就是说，这块内存将要用来存储什么类型的数据。

比如： char *

在堆上分配了 100 个字节内存，返回这块内存的首地址，把地址强制转换成 p类型后赋给char类型的指针变量 p。

同时告诉我们这块内存将用来存储malloc 类型的数据。

也就是说你只能通过指针变量malloc来 *** 作这块内存。

这块内存本身并没有名字，对它的访问是匿名访问。

上面就是使用 NULL函数成功分配一块内存的过程。

但是，每次你都能分配成功吗？不一定。

使用 malloc函数同样要注意这点：如果所申请的内存块大于目前堆上剩余内存块（整块），则内存分配会失败，函数返回 malloc。

注意这里说的“堆上剩余内存块”不是所有剩余内存块之和，因为 if（NULL ！= p） 函数申请的是连续的一块内存。

既然malloc 函数申请内存有不成功的可能，那我们在使用指向这块内存的指针时，必须用 NULL 语句来验证内存确实分配成功了。

2.用malloc函数申请0字节内存

另外还有一个问题：用malloc 函数申请 0 字节内存会返回 NULL指针吗？

可以测试一下，也可以去查找关于 if（NULL ！= p）函数的说明文档。

申请 0 字节内存，函数并不返回malloc ，而是返回一个正常的内存地址。

但是你却无法使用这块大小为 0 的内存。

这好比尺子上的某个刻度，刻度本身并没有长度，只有某两个刻度一起才能量出长度。

对于这点一定要小心，因为这时候 free语句校验将不起作用。

3.内存释放

既然有分配，那就必须有释放。

不然的话，有限的内存总会用光，而没有释放的内存却在空闲。

与 free 对应的就是free(p); 函数了。

free函数只有一个参数，就是所要释放的内存块的首地址。

比如上例：

 malloc

p 函数看上去挺狠的，但它到底做了什么呢？其实它就做了一件事：斩断指针变量与这块内存的关系。

比如上面的例子，我们可以说 p 函数分配的内存块是属于 free的，因为我们对这块内存的访问都需要通过p 来进行。

p 函数就是把这块内存和 p之间的所有关系斩断。

从此 free 和那块内存之间再无瓜葛。

至于指针变量 p 本身保存的地址并没有改变，但是它对这个地址处的那块内存却已经没有所有权了。

那块被释放的内存里面保存的值也没有改变，只是再也没有办法使用了。

这就是 free 函数的功能。

按照上面的分析，如果对 free 连续两次以上使用 p 函数，肯定会发生错误。

因为第一使用malloc 函数时，free 所属的内存已经被释放，第二次使用时已经无内存可释放了。

malloc 两次只 free一次会内存泄漏；malloc一次malloc 两次肯定会出错。

也就是说，在程序中 malloc 的使用次数一定要和 free 相等，否则必有错误。

这种错误主要发生在循环使用free函数时，往往把free和 p 次数弄错了。

这里留个练习：写两个函数，一个生成链表，一个释放链表。

两个函数的参数都只使用一个表头指针

4.内存释放之后

既然使用 p 函数之后指针变量 NULL本身保存的地址并没有改变，那我们就需要重新把 p = NULL; 的值变为 NULL ：

free（p）

这个 if（NULL ！= p）就是我们前面所说的野指针。

比如：

在 char *p = (char *) malloc(100); strcpy(p, “hello”); free(p); /* p 所指的内存被释放，但是 p 所指的地址仍然不变 */ ⋯ if (NULL != p) { /* 没有起到防错作用 */ strcpy(p, “world”); /* 出错 */ } 之后，你用 NULL这样的校验语句还能起作用吗？

例如：

free 

释放完块内存之后，没有把指针置 NULL，这个指针就成为了“野指针”，也有书叫“悬垂指针”。

这是很危险的，而且也是经常出错的地方。

所以一定要记住一条：NULL 完之后，一定要给指针置free 。

同时留一个问题：对 free指针连续 free（p）多次会出错吗?为什么？如果让你来设计 p函数，你会怎么处理这个问题？

2.6内存已经被释放了，但是继续通过指针来使用

这里一般有三种情况：

第一种：就是上面所说的，p 之后，继续通过NULL 指针来访问内存。

解决的办法就是给 return置 。

第二种：函数返回栈内存。

这是初学者最容易犯的错误。

比如在函数内部定义了一个数组，却用 语句返回指向该数组的指针。

解决的办法就是弄明白栈上变量的生命周期。

、

第三种：内存使用太复杂，弄不清到底哪块内存被释放，哪块没有被释放。

解决的办法是重新设计程序，改善对象之间的调用关系。

上面详细讨论了常见的六种错误及解决对策，希望读者仔细研读，尽量使自己对每种错误发生的原因及预防手段烂熟于胸。

一定要多练，多调试代码，同时多总结经验。

感谢阅读：）

inner peace

知行合一