c语言中malloc是啥？怎么用?

Posted 2023-05-13

malloc() 函数用来动态地分配内存空间，其原型为：void* malloc (size_t size);

说明：

【参数说明】

size 为需要分配的内存空间的大小，以字节（Byte）计。

【函数说明】

malloc() 在堆区分配一块指定大小的内存空间，用来存放数据。这块内存空间在函数执行完成后不会被初始化，它们的值是未知的。如果希望在分配内存的同时进行初始化，请使用 calloc() 函数。

【返回值】

分配成功返回指向该内存的地址，失败则返回 NULL。

操作：

由于申请内存空间时可能有也可能没有，所以需要自行判断是否申请成功，再进行后续操作。

如果 size 的值为 0，那么返回值会因标准库实现的不同而不同，可能是 NULL，也可能不是，但返回的指针不应该再次被引用。

注意：函数的返回值类型是 void *，void 并不是说没有返回值或者返回空指针，而是返回的指针类型未知。所以在使用 malloc() 时通常需要进行强制类型转换，将 void 指针转换成我们希望的类型，例如：

#include<stdlib.h>

typedef int ListData;

ListData *data;  //存储空间基址

data = ( ListData * ) malloc( 100 * sizeof ( ListData ) );

扩展资料

实现malloc的方法：

(1)数据结构 

首先我们要确定所采用的数据结构。一个简单可行方案是将堆内存空间以块的形式组织起来，每个块由meta区和数据区组成，meta区记录数据块的元信息（数据区大小、空闲标志位、指针等等）。

数据区是真实分配的内存区域，并且数据区的第一个字节地址即为malloc返回的地址 。

（2）寻找合适的block 

现在考虑如何在block链中查找合适的block。一般来说有两种查找算法： 

First fit:从头开始，使用第一个数据区大小大于要求size的块所谓此次分配的块 

Best fit:从头开始，遍历所有块，使用数据区大小大于size且差值最小的块作为此次分配的块 

两种方式各有千秋，best fit有较高的内存使用率（payload较高），而first fit具有较高的运行效率。这里我们采用first fit算法。

（3）开辟新的block 
如果现有block都不能满足size的要求，则需要在链表最后开辟一个新的block。

（4）分裂block 
First fit有一个比较致命的缺点，就是可能会让更小的size占据很大的一块block，此时，为了提高payload,应该在剩余数据区足够大的情况下，将其分裂为一个新的block。

（5）malloc的实现 

有了上面的代码，我们就可以实现一个简单的malloc.注意首先我们要定义个block链表的头first_block,初始化为NULL；另外，我们需要剩余空间至少有BLOCK_SIZE+8才执行分裂操作 

由于我们需要malloc分配的数据区是按8字节对齐，所以size不为8的倍数时，我们需要将size调整为大于size的最小的8的倍数。

参考技术A

C语言中malloc是动态内存分配函数。

函数原型：void *malloc(unsigned int num_bytes)；

参数：num_bytes 是无符号整型，用于表示分配的字节数；

返回值：如果分配成功则返回指向被分配内存的指针(此存储区中的初始值不确定)，否则返回空指针NULL。void* 表示未确定类型的指针，void *可以指向任何类型的数据，更明确的说是指申请内存空间时还不知道用户是用这段空间来存储什么类型的数据（比如是char还是int或者其他类型）；

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

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

注意：当内存不再使用时，应使用free()函数将内存块释放。函数返回的指针一定要适当对齐，使其可以用于任何数据对象。关于该函数的原型，在以前malloc返回的是char型指针，新的ANSIC标准规定，该函数返回为void型指针，因此必要时要进行类型转换。

总结：malloc()函数其实就在内存中找一片指定大小的空间，然后将这个空间的首地址范围给一个指针变量，这里的指针变量可以是一个单独的指针，也可以是一个数组的首地址，这要看malloc()函数中参数size的具体内容。

我们这里malloc分配的内存空间在逻辑上连续的，而在物理上可以连续也可以不连续。对于我们程序员来说，我们关注的是逻辑上的连续，因为操作系统会帮我们安排内存分配，所以我们使用起来就可以当做是连续的。

程序例子：

# include <stdio.h>

# include <malloc.h>  

int main(void)

int i = 5; //分配了4个字节 静态分配

int * p = (int *)malloc(sizeof(4));//指针变量p为静态分配,malloc开辟的空间为动态分配

*p = 5; //*p 代表的就是一个int变量,指针变量p表示是一个以int类型的地址为内容的变量

free(p); //freep(p)表示把p所指向的内存给释放掉,p本身的内存是静态的，不能由程序员手动释放

//p本身的内存只能在p变量所在的函数运行终止时由系统自动释放 

return 0;

扩展资料：

malloc在标准库里的代码实现：

#define NULL 0

#define MEMSEZE 8096

typedef double Align;

typedef union header

struct

union header* next;

unsigned usedsize;

unsigned freesize;

s;

Align a;

header;

static Header mem[MEMSIZE];

static Header* memptr=NULL;

void* malloc(unsigned nbytes)

Header *p,*newp;

unsigned nunits;

nunits=(nbytes+sizeof(Header)-1)/sizeof(Header)+1;

if(memptr==NULL)

memptr->s.next=memptr=mem;

memptr->s.usedsize=1;

memptr->s.freesize=MEMSIZE-1;

for(p=memptr;(p->s.next!=memptr) && (p->s.freesize<nunits);p=p->s.next);

if(p->freesize<nunits) return NULL;

newp=p+p->s.usedsize;

newp->s.usedsize=nunits;

newp->s.freesize=p->s.freesize-nunits;

newp->s.next=p->s.next;

p->s.freesize=0;

p->s.next=newp;

memptr=newp;

return (void*)(newp+1);

void free(void* ap)

Header *bp,*p,*prev;

bp=(Header*)ap-1;

for(prev=memptr,p=memptr->s.next;

(p!=bp) && (p!=memptr);prev=p,p=p->next);

if(p!=bp) return;

prev->s.freesize+=p->s.usedsize+p->s.freesize;

prev->s.next=p->s.next;

memptr=prev;

c语言中malloc的意义：

malloc就是memory allocate动态分配内存,malloc的出现时为了弥补静态内存分配的缺点，静态分配内存有如下缺点：

1、比如说，传统的一维数组，如int a[5]，使用传统的一维数组需要事先指定数组的长度，而且数组的长度必须是一个常量（宏定义的 常量）

2、传统数组(静态分配),不能手动释放，只能等待系统释放，静态分配的变量在该函数内运行的时候有效，当静态分配的变量所在函数运行完之后，该内存会自动释放。静态分配的内存，是在栈中分配的，其实在C语言中的函数调用也是通过栈来实现的，栈这种数据结构的一个特点就是（先进后出）。

所以，在调用函数的时候，都是先压入栈中，然后，再从最上面的函数开始执行，最后，执行到main函数结束。动态分配通过malloc分配，是在堆中分配的，堆不是一种数据结构，它是一种排序方式，堆排序。

3、传统数组的长度一旦定义之后，就不能更改，比如说，如果我有一个业务在这之前给分配的大小为100，但是，我现在由于业务数量的增长，原来的大小就无法满足。

4、静态分配不能跨函数调用，就是无法在另一个函数中，来管理一个函数中的内存。静态分配，只在当前函数有效，当，静态分配所在的函数运行完之后，该变量就不能被其他的函数所调用。

参考资料：百度百科-malloc

参考技术B 动态分配内存。原型extern void *malloc(unsigned int num_bytes);头文件功能分配长度为num_bytes字节的内存块返回值如果分配成功则返回指向被分配内存的指针(此存储区中的初始值不确定)，否则返回空指针NULL。当内存不再使用时，应使用free()函数将内存块释放。函数返回的指针一定要适当对齐，使其可以用于任何数据对象。说明关于该函数的原型，在以前malloc返回的是char型指针，新的ANSIC标准规定，该函数返回为void型指针，因此必要时要进行类型转换。名称解释malloc的全称是memory allocation，中文叫动态内存分配，当无法知道内存具体位置的时候，想要绑定真正的内存空间，就需要用到动态的分配内存。相关函数calloc、realloc、free、_alloca2函数声明编辑全名void *malloc(size_t size);备注void* 表示未确定类型的指针，void *可以指向任何类型的数据，更明确的说是指申请内存空间时还不知道用户是用这段空间来存储什么类型的数据（比如是char还是int或者...）3与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 返回指定类型的指针，并且可以自动计算所需要大小。比如：?123int*p;p=new int;//返回类型为int*类型(整数型指针)，分配大小为sizeof(int);或：?123int*parr;parr=new int[100];//返回类型为int*类型(整数型指针)，分配大小为sizeof(int)*100;而 malloc 则必须要由我们计算字节数，并且在返回后强行转换为实际类型的指针。?1234567int*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:?12345678910type*p;if(NULL==(p=(type*)malloc(sizeof(type))))/*请使用if来判断,这是有必要的*/perror("error...");exit(1);.../*其它代码*/free(p);p=NULL;/*请加上这句*/malloc 也可以达到 new [] 的效果，申请出一段连续的内存，方法无非是指定你所需要内存大小。比如想分配100个int类型的空间：?12int*p=(int*)malloc(sizeof(int)*100);//分配可以放得下100个整数的内存空间。另外有一点不能直接看出的区别是，malloc 只管分配内存，并不能对所得的内存进行初始化，所以得到的一片新内存中，其值将是随机的。除了分配及最后释放的方法不一样以外，通过malloc或new得到指针，在其它操作上保持一致。对其做一个特例补充?12345char*ptr;if((ptr=(char*)malloc(0))==NULL)puts("Gotanullpointer");elseputs("Gotavalidpointer");此时得到的是Got a valid pointer。把0赋给malloc能得到一个合法的指针。4工作机制编辑malloc函数的实质体现在，它有一个将可用的内存块连接为一个长长的列表的所谓空闲链表。调用malloc函数时，它沿连接表寻找一个大到足以满足用户请求所需要的内存块。然后，将该内存块一分为二（一块的大小与用户请求的大小相等，另一块的大小就是剩下的字节）。接下来，将分配给用户的那块内存传给用户，并将剩下的那块（如果有的话）返回到连接表上。调用free函数时，它将用户释放的内存块连接到空闲链上。到最后，空闲链会被切成很多的小内存片段，如果这时用户申请一个大的内存片段，那么空闲链上可能没有可以满足用户要求的片段了。于是，malloc函数请求延时，并开始在空闲链上翻箱倒柜地检查各内存片段，对它们进行整理，将相邻的小空闲块合并成较大的内存块。如果无法获得符合要求的内存块，malloc函数会返回NULL指针，因此在调用malloc动态申请内存块时，一定要进行返回值的判断。Linux Libc6采用的机制是在free的时候试图整合相邻的碎片，使其合并成为一个较大的free空间。5程序示例编辑正常程序?12345678910111213141516171819typedefstructdata_typeintage;charname[20];data;data*bob=NULL;bob=(data*)malloc(sizeof(data));if(bob!=NULL)bob->age=22;strcpy(bob->name,"Robert");printf("%sis%dyearsold\n",bob->name,bob->age);elseprintf("mallocerror!\n");exit(-1);free(bob);bob=NULL;内存泄漏实例?12345678910111213例1：#include<stdio.h>#include<malloc.h>#defineMAX100000000intmain(void)int*a[MAX]=NULL;inti;for(i=0;i<MAX;i++)a[i]=(int*)malloc(MAX);return0;例2：?123456789101112131415161718192021#include"stdio.h"#include"malloc.h"//malloc()函数被包含在malloc.h里面intmain(void)char*a=NULL;//声明一个指向a的char*类型的指针a=(char*)malloc(100*sizeof(char));//使用malloc分配内存的首地址，然后赋值给aif(!a)//如果malloc失败，可以得到一些logperror("malloc");return-1;sprintf(a,"%s","HelloWorld\n");//"HelloWorld\n"写入a指向的地址printf("%s\n",a);//输出用户输入的数据free(a);//释放掉使用的内存地址return0;//例2有无内存泄露？ 例1：对malloc申请之后没有检测返回值；例2：检测malloc返回值条件有误。 参考技术C

malloc为stdlib.h中声明的一个函数，功能为向系统申请分配指定大小的内存空间。

原型：

void *malloc(unsigned int num_bytes);

参数：

    申请内存空间的大小。

返回值：

    如果分配成功则返回指向被分配内存的指针(此存储区中的初始值不确定)，否则返回空指针NULL。

注意返回类型是 void* 类型，void* 表示未确定类型的指针，可以转换为任何其它类型的指针。malloc申请的内存空间为堆内存，当内存不再使用时，应使用free()函数将内存块释放，否则将造成内存泄漏。

malloc常用于建立数组或为结构体类型分配空间，使用方法如下：

1、若需要建立一个大小为n的int型数组，n由键盘输入，那么就需要这样写：

int *arr, n;

scanf("%d", &n);
arr = malloc(sizeof(int) * n);

2、为结构体指针分配空间，只需要使用sizeof运算符获得结构体类型的大小，然后传入malloc中就可以。

参考技术D malloc() 函数用来动态地分配内存空间，其原型为：void* malloc (size_t size);

说明：

【参数说明】

size 为需要分配的内存空间的大小，以字节（Byte）计。

【函数说明】

malloc() 在堆区分配一块指定大小的内存空间，用来存放数据。这块内存空间在函数执行完成后不会被初始化，它们的值是未知的。如果希望在分配内存的同时进行初始化，请使用 calloc() 函数。

【返回值】

分配成功返回指向该内存的地址，失败则返回 NULL。

操作：

由于申请内存空间时可能有也可能没有，所以需要自行判断是否申请成功，再进行后续操作。

如果 size 的值为 0，那么返回值会因标准库实现的不同而不同，可能是 NULL，也可能不是，但返回的指针不应该再次被引用。

注意：函数的返回值类型是 void *，void 并不是说没有返回值或者返回空指针，而是返回的指针类型未知。所以在使用 malloc() 时通常需要进行强制类型转换，将 void 指针转换成我们希望的类型，例如：

#include<stdlib.h>

typedef int ListData;

ListData *data; //存储空间基址

data = ( ListData * ) malloc( 100 * sizeof ( ListData ) );

C语言中malloc函数的使用方法是啥？

参考技术A C语言中malloc是动态内存分配函数。\\x0d\\x0a函数原型：void *malloc(unsigned int num_bytes);\\x0d\\x0a参数：num_bytes 是无符号整型，用于表示分配的字节数。\\x0d\\x0a返回值：如果分配成功则返回指向被分配内存的指针(此存储区中的初始值不确定)，否则返回空指针NULL。void* 表示未确定类型的指针，void *可以指向任何类型的数据，更明确的说是指申请内存空间时还不知道用户是用这段空间来存储什么类型的数据（比如是char还是int或者...）\\x0d\\x0a功能：分配长度为num_bytes字节的内存块\\x0d\\x0a注意：当内存不再使用时，应使用free()函数将内存块释放。函数返回的指针一定要适当对齐，使其可以用于任何数据对象。关于该函数的原型，在以前malloc返回的是char型指针，新的ANSIC标准规定，该函数返回为void型指针，因此必要时要进行类型转换。\\x0d\\x0a实例：\\x0d\\x0a#include"stdio.h"\\x0d\\x0a \\x0d\\x0a#include"malloc.h"//malloc()函数被包含在malloc.h里面\\x0d\\x0a\\x0d\\x0aint main(void)\\x0d\\x0a\\x0d\\x0a \\x0d\\x0achar*a=NULL;//声明一个指向a的char*类型的指针\\x0d\\x0a \\x0d\\x0aa=(char*)malloc(100*sizeof(char));//使用malloc分配内存的首地址，然后赋值给a\\x0d\\x0a \\x0d\\x0aif(!a)//如果malloc失败，可以得到一些log\\x0d\\x0a \\x0d\\x0a\\x0d\\x0aperror("malloc");\\x0d\\x0areturn-1;\\x0d\\x0a\\x0d\\x0a \\x0d\\x0asprintf(a,"%s","HelloWorld\n");//"HelloWorld\n"写入a指向的地址\\x0d\\x0a \\x0d\\x0aprintf("%s\n",a);//输出用户输入的数据\\x0d\\x0a \\x0d\\x0afree(a);//释放掉使用的内存地址\\x0d\\x0a \\x0d\\x0areturn0;//例2有无内存泄露？\\x0d\\x0a \\x0d\\x0a