动态内存分配详解-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_40025335/article/details/86717086

为什么使用动态内存分配？

当你声明数组时，必须用一个编译时常量指定数组长度。而由于数组所需要的内存空间取决于输入数据，数组长度常常在运行时才知道。通常声明一个较大的数组，让可以容纳更多的元素。

为了避免使用元素数量超过声明的长度，通常会把声明数组得更大一些；但如果实际元素数量较少，声明数组大分部内存空间被浪费了；如果输入数据超过数组范围，需要提示"数组内存溢出"

动态内存分配允许程序为一个长度在运行时才知道的数组分配内存空间。

先具体看两个例子：

程序运行前不知道数组长度，声明数组；

#include <stdio.h>
#include <malloc.h>
int main(void)

{
	int len;
	printf("请输入你要存放的元素的个数：");
	scanf("%d",&len);             //5 
	int s[len];
	s[len]={0};
	printf("s[0]:%d",s[0]);
	return 0;
} 
/*
请输入你要存放的元素的个数：5
s[0]:4210717   ->输出是一个垃圾值
--------------------------------*/

程序运行前不知道数组长度，使用动态内存分配内存空间：

#include <stdio.h>
#include <malloc.h>
int main(void)

{
	//int a[5];//若int占4个字节，则本数组总包含有20个字节，每四个字节被当做一个int变量来 
	int len;
	int * pArr;
	
	printf("请输入你要存放的元素的个数：");
	scanf("%d",&len);             //5
	pArr = (int *)malloc(4*len);
	//pArr = (int *)malloc(4*len); //本行动态的构造了一个一维数组，数组长度len,数组名为pArr，元素类型为int,类似于 int pArr[len];
	//对一维数组进行操作，如：对动态一维数组进行赋值 
	//为什么pArr变成一个数组类型？？？？？？ pArr 为一个指针变量，为数组的首地址？？？ 
	//.pArr本身所占内存为静态分配的，pArr指向的内存是动态分配  
//	pArr = (int *)malloc(len);
	for (int i=0;i<len;i++)
	    scanf("%d",&pArr[i]);
	    
	    
	//对一维数组进行输出
	printf("一维数组的内容是：");
	for (int i=0;i<len;i++)
		printf("%4d",pArr[i]);
	    
	free(pArr);//释放掉动态分配的数组 
	 
	return 0;
	
}
/*
请输入你要存放的元素的个数：5
1
2
3
4
5
一维数组的内容是：   1   2   3   4   5
*/

例子对比很明显，接下来看下动态内存分配相关函数。

1、malloc介绍

malloc函数是一种分配长度为num_bytes字节的内存块的函数，可以向系统申请分配指定size个字节的内存空间。malloc的全称是memory allocation，中文叫动态内存分配，当无法知道内存具体位置的时候，想要绑定真正的内存空间，就需要用到动态的分配内存。

返回类型是 void* 类型。void* 表示未确定类型的指针。C,C++规定，void* 类型可以通过类型转换强制转换为任何其它类型的指针。

malloc分配的内存大小至少为参数所指定的字节数
malloc的返回值是一个指针，指向一段可用内存的起始位置，指向一段可用内存的起始地址，多次调用malloc所分配的地址不能有重叠部分，除非某次malloc所分配的地址被释放掉malloc应该尽快完成内存分配并返回（不能使用NP-hard的内存分配算法）实现malloc时应同时实现内存大小调整和内存释放函数（realloc和free）
malloc和free是配对的，如果申请后不释放就是内存泄露，如果无故释放那就是什么也没做，释放只能释放一次，如果一块空间释放两次或者两次以上会出现错误（但是释放空指针例外，释放空指针也等于什么也没做，所以释放多少次都是可以的。）

2、函数原型

extern void *malloc(unsigned int num_bytes);

头文件：#include <malloc.h> 或 #include <alloc.h> (注意：alloc.h 与 malloc.h 的内容是完全一致的。)

功能：分配长度为num_bytes字节的内存块

说明：如果分配成功则返回指向被分配内存的指针，否则返回空指针NULL。

当内存不再使用时，应使用free()函数将内存块释放。

3、头文件

#include <stdlib.h>或者#include <malloc.h>

4、函数声明

void *malloc(size_t size);

备注：void* 表示未确定类型的指针，void *可以指向任何类型的数据，更明确的说是指申请内存空间时还不知道用户是用这段空间来存储什么类型的数据（比如是char还是int或者其他数据类型）。

5、返回值

如果分配成功则返回指向被分配内存的指针(此存储区中的初始值不确定)，否则返回空指针NULL。当内存不再使用时，应使用free()函数将内存块释放。函数返回的指针一定要适当对齐，使其可以用于任何数据对象。

6、malloc函数说明

关于该函数的原型，在以前malloc返回的是char型指针，新的ANSIC标准规定，该函数返回为void型指针，因此必要时要进行类型转换。

7、malloc相关函数

calloc、realloc、free、_alloca

free函数

对于程序运行结束前，需要使用free()函数去手动释放申请的内存空间，以防出现内存泄露；

8、malloc与new区别

malloc（Linux上具体实现可以参考man malloc，glibc通过brk()&mmap()实现）是libc里面实现的一个函数，如果在source code中没有直接或者间接include过stdlib.h，那么gcc就会报出error：‘malloc’ was not declared in this scope。如果生成了目标文件（假定动态链接malloc），如果运行平台上没有libc（Linux平台，手动指定LD_LIBRARY_PATH到一个空目录即可），或者libc中没有malloc函数，那么会在运行时（Run-time）出错。new则不然，是c++的关键字，它本身不是函数。new不依赖于头文件，c++编译器就可以把new编译成目标代码（g++4.6.3会向目标中插入_Znwm这个函数，另外，编译器还会根据参数的类型，插入相应的构造函数）。

在使用上，malloc 和 new 至少有两个不同: new 返回指定类型的指针，并且可以自动计算所需要大小。比如：

int *p;

p = new int;

//返回类型为int *类型(整数型指针)，分配大小为sizeof(int);

int *parr;

parr = new int[100];

//返回类型为int *类型(整数型指针)，分配大小为sizeof(int) * 100;

而 malloc 则必须要由我们计算字节数，并且在返回后强行转换为实际类型的指针。

int *p;

p = (int*)malloc(sizeof(int) * 128);

//分配128个（可根据实际需要替换该数值）整型存储单元，

//并将这128个连续的整型存储单元的首地址存储到指针变量p中

double *pd = (double*)malloc(sizeof(double) * 12);

//分配12个double型存储单元，

//并将首地址存储到指针变量pd中

第一、malloc 函数返回的是 void * 类型。

对于C++，如果你写成：p = malloc (sizeof(int)); 则程序无法通过编译，报错：“不能将 void* 赋值给 int * 类型变量”。

所以必须通过 (int *) 来将强制转换。而对于C，没有这个要求，但为了使C程序更方便的移植到C++中来，建议养成强制转换的习惯。

第二、函数的实参为 sizeof(int) ，用于指明一个整型数据需要的大小。

在Linux中可以有这样：malloc(0),这是因为Linux中malloc有一个下限值16Bytes，注意malloc(-1)是禁止的；但是在某些系统中是不允许malloc(0)的。

在规范的程序中我们有必要按照这样的格式去使用malloc及free:

type *p;

if(NULL == (p = (type*)malloc(sizeof(type))))

/*请使用if来判断,这是有必要的*/

{

perror("error...");

exit(1);

}

.../*其它代码*/

free(p);

p = NULL;/*请加上这句*/

malloc 也可以达到 new [] 的效果，申请出一段连续的内存，方法无非是指定你所需要内存大小。

比如想分配100个int类型的空间：

1 2	`int` `p = (int)malloc(sizeof(int) * 100);` `//分配可以放得下100个整数的内存空间。`

另外有一点区别，malloc 只管分配内存，并不能对所得的内存进行初始化，所以得到的一片新内存中，其值将是随机的。

除了分配及最后释放的方法不一样以外，通过malloc或new得到指针，在其它操作上保持一致。

对其做一个特例补充

char *ptr;

if((ptr = (char*)malloc(0)) == NULL)

puts("Gotanullpointer");

else

puts("Gotavalidpointer");

此时得到的是Got a valid pointer。把0赋给malloc能得到一个合法的指针。

malloc函数工作机制

编辑

malloc函数的实质体现在，它有一个将可用的内存块连接为一个长长的列表的所谓空闲链表。调用malloc函数时，它沿连接表寻找一个大到足以满足用户请求所需要的内存块。然后，将该内存块一分为二（一块的大小与用户请求的大小相等，另一块的大小就是剩下的字节）。接下来，将分配给用户的那块内存传给用户，并将剩下的那块（如果有的话）返回到连接表上。调用free函数时，它将用户释放的内存块连接到空闲链上。到最后，空闲链会被切成很多的小内存片段，如果这时用户申请一个大的内存片段，那么空闲链上可能没有可以满足用户要求的片段了。于是，malloc函数请求延时，并开始在空闲链上翻箱倒柜地检查各内存片段，对它们进行整理，将相邻的小空闲块合并成较大的内存块。如果无法获得符合要求的内存块，malloc函数会返回NULL指针，因此在调用malloc动态申请内存块时，一定要进行返回值的判断。

Linux Libc6采用的机制是在free的时候试图整合相邻的碎片，使其合并成为一个较大的free空间。

例子1

#include <stdio.h>

#include <malloc.h> // 不能省 malloc 是menory allocate 的缩写 

int main(void)
{
    int i=5; //分配了4个字节 静态分配 
    int * p = (int *)malloc(4);//12行 

    if(p == NULL)

       printf("erro");
    /* 解释
    1.要使用malloc函数，必须添加malloc.h这个头文件
    2.malloc 函数只有一个形参，并且形参是整型
    3. 4表示请求系统为本程序分配4个字节
    4.malloc 函数只能返回第一个字节的地址 
    5.12行分配了8个字节 ，p变量静态内存占4个字节，p指向的动态内存占4个字节？ 
    6.p本身所占内存为静态分配的，p指向的内存是动态分配 
    */ 
    *p=5;   //*p代表的就是一个int变量，只不过*p这个类型分配方式和11行内存分配方式不同 
    //int t=sizeof(*p);
    free(p);    //    free(p)表示吧p所指向的内存给释放掉 
 //printf("HELLO\n"); //p本身所占内存为静态分配的，不能手动释放，只能在p变量所在的函数运行结束后才会被释放 
    printf("%d\n",*p);//指针变量p地址里存储的已经被释放了，打印的为垃圾值 
 //      printf("%d\n",t); //输出t=4； 
    return 0;
  
}

例子2

#include <stdio.h>
#include <malloc.h>//动态变量 
void f(int *q)
{
    //*p=200;//error
    //q=200;
    *q=200;
    //**q=200;//error ,*q代表整型变量不能 在前面加* 
    //free(q);将q释放后将无法输出*q的值，系统会产生一个垃圾值 
}


int main(void)
{
    int t=sizeof(int);          //sizeof(int)返回值是int 所占的字节数 
    int *p = (int *)malloc(t);
                             //指针变量p表示系统分配内存单元的地址 
    *p=10;                  //*p=10；表示见整型值10装进个这个地址，故该地址的值为10，即*p是值为10； 
    
    printf("%d\n",*p);//10
    
    f(p);
    printf("%d\n",*p);//200
    return 0;
}

例子3


#include <stdio.h>
#include <malloc.h> // 不能省 malloc 是menory allocate 的缩写 

int main(void)
{
    int i=5; //分配了4个字节 静态分配 
    int * p = (int *)malloc(4);// 分配个4个字节空间
    /*
    1.要使用malloc函数，必须添加malloc.h这个头文件
    2.malloc 函数只有一个形参，并且形参是整型
    3. 4表示请求系统为本程序分配4个字节
    4.malloc 函数只能返回第一个字节的地址 
    5.12行分配了8个字节 ，p变量静态内存占4个字节，p指向的动态内存占4个字节。
    6.p本身所占内存为静态分配的，p指向的内存是动态分配 
    */ 
    *p=5;   //*p代表的就是一个int变量，只不过*p这个类型分配方式和11行内存分配方式不同 
    //int t=sizeof(*p);
    free(p);    //    free(p)表示吧p所指向的内存给释放掉 
 //printf("HELLO\n"); //p本身所占内存为静态分配的，不能手动释放，只能在p变量所在的函数运行结束后才会被释放 
    printf("%d\n",*p);//指针变量p地址里存储的已经被释放了，打印的为垃圾值 
 //      printf("%d\n",t); //输出t=4； 
    return 0;
    
}



结果：

1991120

--------------------------------
Process exited after 0.6203 seconds with return value 0
请按任意键继续. . .

例子4

#include <stdio.h>
#include <malloc.h>//动态变量 
void f(int *q)
{
    //*p=200;//error
    //q=200;
    *q=200;
    //**q=200;//error ,*q代表整型变量不能 在前面加* 
    //free(q);将q释放后将无法输出*q的值，系统会产生一个垃圾值 
}


int main(void)
{
    int t=sizeof(int);          //sizeof(int)返回值是int 所占的字节数 
    int *p = (int *)malloc(t);
                             //指针变量p表示系统分配内存单元的地址 
    *p=10;                  //*p=10；表示见整型值10装进个这个地址，故该地址的值为10，即*p是值为10； 
    
    printf("%d\n",*p);//10
    
    f(p);
    printf("%d\n",*p);//200
    return 0;
    
}

结果：

10
200

--------------------------------
Process exited after 0.4514 seconds with return value 0
请按任意键继续. .

参考

https://blog.youkuaiyun.com/chf_1/article/details/78688557