c语言malloc头文件,C语言中的malloc()函数

c语言malloc头文件,C语言中的malloc()函数详细介绍

本文目录一览： 一个c语言程序中基本都会包含哪两个文件？

一般情况下，一个C语言程序会包含以下两个文件：
1. stdio.h：包含标准输入输出库的头文件。它提供了一些函数，使得数据的输入和输出变得简单化，如printf()、scanf()等。
2. stdlib.h：包含C语言标准库的头文件。它提供了很多常用的函数，如malloc()、free()等，这些函数在C语言的函数库中经常被使用。
当然，具体程序中使用哪些头文件，也取决于程序所使用的功能和需要。

C语言中使用malloc必须加#include(mallo.h)？

首先malloc函数一般头文件是stdlib.h；
然后在你不加头文件也能编译原因是你的编译检查不是非常严格，然后在链接的时候编译器把包含malloc函数的静态库也放进来链接了，所以编译器能找到这个函数的实现没有问题，但一般编译器肯定会报警告。

#include(malloc.h)在c语言中是什么意思？

#include

在c语言中表示导入malloc.h头文件，程序中可能会使用该头文件中定义的函数、宏和定变量等；

malloc.h，动态存储分配函数头文件，当对内存区进行操作时，调用相关函数。ANSI标准建议使用stdlib.h头文件，但许多C编译要求用malloc.h，使用时应查阅有关手册。

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

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

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

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

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

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

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

c语言中malloc是什么？怎么用？

C语言中malloc是动态内存分配函数。
函数原型：void *malloc(unsigned int num_bytes)；
参数：num_bytes 是无符号整型，用于表示分配的字节数；
返回值：如果分配成功则返回指向被分配内存的指针(此存储区中的初始值不确定)，否则返回空指针NULL。void* 表示未确定类型的指针，void *可以指向任何类型的数据，更明确的说是指申请内存空间时还不知道用户是用这段空间来存储什么类型的数据（比如是char还是int或者其他类型）；
头文件：#include

或 #include

(注意：alloc.h 与 malloc.h 的内容是完全一致的。)

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

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

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

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

程序例子：

# include

# include

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

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

动态分配内存。原型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程序示例编辑正常程序?12345678910111213800819typedefstructdata_type{intage;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);}else{printf("mallocerror!\n");exit(-1);}free(bob);bob=NULL;内存泄漏实例?12345678910111213例1：#include

#include

#defineMAX100000000intmain(void){int*a[MAX]={NULL};inti;for(i=0;i
<max;i++){a[i]=(int*)malloc(max);}return0;}例2：?123456789101112138008192021#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失败，可以得到一些log{perror("malloc");return-1;}sprintf(a,"%s","HelloWorld\n");//"HelloWorld\n"写入a指向的地址printf("%s\n",a);//输出用户输入的数据free(a);//释放掉使用的内存地址return0;//例2有无内存泄露？}" 例1：对malloc申请之后没有检测返回值；例2：检测malloc返回值条件有误。
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中就可以。

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

说明：

【参数说明】

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

【函数说明】

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

【返回值】

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

操作：

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

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

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

#include

typedef int ListData;

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

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

分配存储空间，输入 空间大小。输出 返回指向已分配的空间的指针。如果分配失败，返回NULL

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

说明：

【参数说明】

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

【函数说明】

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

【返回值】

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

操作：

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

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

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

#include

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的倍数。

在c++中，malloc函数的头文件是什么

它跟C语言是一样的！ 也是动态的申请空间，例如： int *p;
根据网上的搜索结果，C++中，malloc函数的头文件是stdlib.h或者cstdlib。malloc函数的原型是：
extern void *malloc (unsigned int num_bytes);
malloc函数的功能是在内存上分配一段长度为num_bytes个字节大小的空间，并返回一个void类型的指针。
有2个头文件都可以
C头文件,

调用时 malloc(x);

C++头文件,

注意没有后缀名

调用时要写 std::malloc(x) 注意std前缀

c语言中malloc函数包含在哪个头文件中？

同编译器有关。
头文件
ANSI
C
等
需包含

和

两者

MS

VC++

写

包含

即可

MS

VC++

编译时用库：

LIBC.LIB

单线程，LIBCMT.LIB

多线程，

和

MSVCRT.LIB

malloc怎么使用，请举例说明，谢谢！

malloc 原型：extern void *malloc(unsigned int num_bytes);
用法：#include

或#include

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

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

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

malloc的语法是：指针名=（数据类型*）malloc（长度）,（数据类型*）表示指针.

malloc（）是C语言中动态存储管理的一组标准库函数之一。其作用是在内存的动态存储区中分配一个长度为size的连续空间。其参数是一个无符号整形数，返回值是一个指向所分配的连续存储域的起始地址的指针。

动态内存分配就是指在程序执行的过程中动态地分配或者回收存储空间的分配内存的方法。动态内存分配不像数组等静态内存分配方法那样需要预先分配存储空间，而是由系统根据程序的需要即时分配，且分配的大小就是程序要求的大小。本文简单介绍动态内存分配函数malloc（）及几种实现方法。

1． 简介

malloc（）是C语言中动态存储管理的一组标准库函数之一。其作用是在内存的动态存储区中分配一个长度为size的连续空间。其参数是一个无符号整形数，返回值是一个指向所分配的连续存储域的起始地址的指针。还有一点必须注意的是，当函数未能成功分配存储空间（如内存不足）就会返回一个NULL指针。所以在调用该函数时应该检测返回值是否为NULL并执行相应的操作。

2． 函数说明

C语言的动态存储管理由一组标准库函数实现，其原型在标准文件

里描述，需要用这些功能时应包含这个文件。与动态存储分配有关的函数共有四个，其中就包括存储分配函数malloc（）。函数原型是：void *malloc (size_t n);这里的size_t是标准库里定义的一个类型，它是一个无符号整型。这个整型能够满足所有对存储块大小描述的需要，具体相当于哪个整型由具体的C系统确定。malloc的返回值为(void *)类型（这是通用指针的一个重要用途），它分配一片能存放大小为n的数据的存储块，返回对应的指针值；如果不能满足申请（找不到能满足要求的存储块）就返回NULL。在使用时，应该把malloc的返回值转换到特定指针类型，赋给一个指针。

注意，虽然这里的存储块是通过动态分配得到的，但是它的大小也是确定的，同样不允许越界使用。例如上面程序段分配的块里能存n个双精度数据，随后的使用就必须在这个范围内进行。越界使用动态分配的存储块，尤其是越界赋值，可能引起非常严重的后果，通常会破坏程序的运行系统，可能造成本程序或者整个计算机系统垮台。

下例是一个动态分配的例子：

#include

#include

main()

{

int count,*array; /*count是一个计数器，array是一个整型指针，也可以理解为指向一个整型数组的首地址*/

count=100;

if((array=(int *)malloc(10*sizeof(int))) == NULL)

{

printf("不能成功分配存储空间。");

exit(1);

}

for(count=0;count<10;count++) /*给数组赋值*/

array[count]=count;

for(count=0;count<10;count++) /*打印数组元素*/

printf("%2d",array[count]);

}

上例中动态分配了10个整型存储区域，然后进行赋值并打印。例中if((array=(int *) malloc (10*sizeof(int)))==NULL)语句可以分为以下几步：

1）分配10个整型的连续存储空间，并返回一个指向其起始地址的整型指针

2）把此整型指针地址赋给array

3）检测返回值是否为NULL

char *p,

p=(char*)malloc(char)

是申请一个动态单元的函数

原形是void * malloc(单元大小)

返回值是一个指针，是个地址

单元大小可以是2，3，4，随便写，与具体环境有关

例如，struct num{int i,long j;}*p;

你就可以这样写p=(struct num* )malloc(sizeof(struct student))就是分配一个大小为sizeof(struct student )的单元给指针p

申请动态内存

char型的：

char* ch = (char*)malloc(sizeof(char)*n)

里面n为你要申请的字节个数

int型的：

int* nNum = (int*)malloc(sizeof(int)*n)

里面n为你要申请的每四字节的个数。

用完后最后要free（ch）掉你申请的内存空间，以免内存泄漏

malloc使用须要包括头文件：

#include 'stdlib.h'

例如：

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));

扩展资料：malloc 函数返回的是 void * 类型。

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

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

在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;/*请加上这句*/

C语言中的malloc()函数

　　原型：extern void *malloc(unsigned int num_bytes);
　　头文件：#include

或 #include

(注意：alloc.h 与 malloc.h 的内容是完全一致的。)

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

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

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

　　使用方法举例：

#include

#include

int main() { char *p; p=(char *)malloc(100); if(p) printf("Memory Allocated at: %x/n",p); else printf("Not Enough Memory!/n"); free(p); return 0; }

#include

#include

int

main()

{

int

*p

,*q

;

int

i;

q=p=(int

*)malloc(12);//q,p是同时指向同一块空间,就是说只申请了一块内存

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

{

scanf("%d",p++);

}

for(i=0;i<3;q++,i++)//而你又改变了q,p的指向,释放的空间就不是原先申请的内存了

{

printf("%d\n",*q);

}

// free(p);

free(q);//而这里却是释放两块内存

return

0;

}

我想这么改

#include

#include

int

main()

{

int

*p

,*q

;

int

i

;

q=p=(int

*)malloc(12)

;

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

{

scanf("%d",p++);

}

p=q;

for(i=0;i<3;q++,i++)

{

printf("%d\n",*q);

}

free(p);

}

头文件：#include

char *p;

p=(char *)malloc(100);

需要包含头文件：

＃i nclude

或

＃i nclude

函数声明(函数原型)：

void *malloc(int size);

说明：malloc 向系统申请分配指定size个字节的内存空间。返回类型是 void* 类型。void* 表示未确定类型的指针。C,C++规定，void* 类型可以强制转换为任何其它类型的指针。

从函数声明上可以看出。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));

第一、malloc 函数返回的是 void * 类型，如果你写成：p = malloc (sizeof(int)); 则程序无法通过编译，报错：“不能将 void* 赋值给 int * 类型变量”。所以必须通过 (int *) 来将强制转换。

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

int* p = (int *) malloc (1);

代码也能通过编译，但事实上只分配了1个字节大小的内存空间，当你往里头存入一个整数，就会有3个字节无家可归，而直接“住进邻居家”！造成的结果是后面的内存中原有数据内容全部被清空。

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

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

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

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

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

C语言中的动态内存分配malloc calloc realloc free 等得具体格式是怎样的？

1.malloc 的格式：void *malloc( size_t size );返回的是一个空的指针所以应用时：
定义一个：int * a分配n个字节的空间：a = (int*)malloc(n);//一定要进行强制类型转换，你定义的说什么类型就强制转换成什么类型的。
2.calloc 的格式：void *calloc( size_t num, size_t size );参数1 num ：Number of elements
参数2 size ：Length in bytes of each element；
Example
/* CALLOC.C: This program uses calloc to allocate space for
* 40 long integers. It initializes each element to zero.
*/
#include

#include

void main( void )

{

long *buffer;

buffer = (long *)calloc( 40, sizeof( long ) );

if( buffer != NULL )

printf( "Allocated 40 long integers\n" );

else

printf( "Can't allocate memory\n" );

free( buffer );

}

Output

Allocated 40 long integers

3.void *realloc( void *memblock, size_t size );

Example

/* REALLOC.C: This program allocates a block of memory for

* buffer and then uses _msize to display the size of that

* block. Next, it uses realloc to expand the amount of

* memory used by buffer and then calls _msize again to

* display the new amount of memory allocated to buffer.

*/

#include

#include

#include

void main( void )

{

long *buffer;

size_t size;

if( (buffer = (long *)malloc( 1000 * sizeof( long ) )) == NULL )

exit( 1 );

size = _msize( buffer );

printf( "Size of block after malloc of 1000 longs: %u\n", size );

/* Reallocate and show new size: */

if( (buffer = (long *)realloc( buffer, size + (1000 * sizeof( long )) ))

== NULL )

exit( 1 );

size = _msize( buffer );

printf( "Size of block after realloc of 1000 more longs: %u\n",

size );

free( buffer );

exit( 0 );

}

Output

Size of block after malloc of 1000 longs: 4000

Size of block after realloc of 1000 more longs: 8000

4.void free( void *memblock );

Example

/* MALLOC.C: This program allocates memory with

* malloc, then frees the memory with free.

*/

#include

/* For _MAX_PATH definition */

#include

#include

void main( void )

{

char *string;

/* Allocate space for a path name */

string = (char *)malloc( _MAX_PATH );

if( string == NULL )

printf( "Insufficient memory available\n" );

else

{

printf( "Memory space allocated for path name\n" );

free( string );

printf( "Memory freed\n" );

}

}

Output

Memory space allocated for path name

Memory freed

一般申请大的内存时使用:

char *string;

string = (char *)malloc(256); //申请256字节的字符串

free(string); //用完后记得释放内存

=======

string = (char *)malloc(128);

str = realloc(string, 256); //128太小，重新申请256大小。

这些用法可以搜索“C库函数大全”，里面有各种库函数的详细用法和举例

malloc（配置内存空间）

相关函数 calloc，free，realloc，brk

表头文件 #include

定义函数 void * malloc(size_t size);

函数说明 malloc()用来配置内存空间，其大小由指定的size决定。

返回值 若配置成功则返回一指针，失败则返回NULL。

范例 void p = malloc(1024); /*配置1k的内存*/

calloc（配置内存空间）

相关函数 malloc，free，realloc，brk

表头文件 #include

定义函数 void *calloc(size_t nmemb，size_t size);

函数说明 calloc()用来配置nmemb个相邻的内存单位，每一单位的大小为size，并返回指向第一个元素的指针。这和使用下列的方式效果相同:malloc(nmemb*size);不过，在利用calloc()配置内存时会将内存内容初始化为0。

返回值 若配置成功则返回一指针，失败则返回NULL。

范例 /* 动态配置10个struct test 空间*/

#include

struct test

{

int a[10];

char b[20];

}

main()

{

struct test *ptr=calloc(sizeof(struct test),10);

}

　

free（释放原先配置的内存）

相关函数 malloc，calloc，realloc，brk

extern void *realloc(void *mem_address, unsigned int newsize);

　　语法：指针名=（数据类型*）realloc（要改变内存大小的指针名，新的大小）。//新的大小一定要大于原来的大小不然的话会导致数据丢失！

　　头文件：#include

有些编译器需要#include

，在TC2.0中可以使用alloc.h头文件

　　功能：先按照newsize指定的大小分配空间，将原有数据从头到尾拷贝到新分配的内存区域，而后释放原来mem_address所指内存区域，同时返回新分配的内存区域的首地址。即重新分配存储器块的地址。

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

　　注意：这里原始内存中的数据还是保持不变的。当内存不再使用时，应使用free()函数将内存块释放。

表头文件 #include

定义函数 void free(void *ptr);

函数说明 参数ptr为指向先前由malloc()、calloc()或realloc()所返回的内存指针。调用free()后ptr所指的内存空间便会被收回。假若参数ptr所指的内存空间已被收回或是未知的内存地址，则调用free()可能会有无法预期的情况发生。若参数ptr为NULL，则free()不会有任何作用。

malloc函数头文件用哪个？有的写malloc.h ，有的写stdlib.h ，还有的写alloc.h 。。。。

看编译器吧，
malloc.h
stdlib.h
alloc.h
都有这个函数，随便包含一个，
但编译器vc6 不支持alloc.h，只能用前两个,我习惯于stdlib.h
简单来说， 在Microsoft Visual C++环境下，malloc.h和stdlib.h中都包含了对malloc函数的声明，所以包含任何一个都可以调用malloc函数；而alloc.h是Borland C++环境下的头文件，也是Linux/Unix环境下进行C语言开发的头文件，所以在这些环境下调用malloc函数要包含alloc.h。