malloc函数的使用格式,在CCS的C编程中怎么使用malloc函数

malloc函数的使用格式,在CCS的C编程中怎么使用malloc函数详细介绍

本文目录一览： malloc函数的用法

malloc函数的用法是：
1、工具/原料：Microsoft Visual Studio2010。
2、打开vs2010，新建一个项目。
3、在malloc的使用.c文件中包含各种需要用到的头文件。
4、输入主体函数main。
5、定义一个指针p，将其初始化为NULL。
6、输入malloc函数。
7、其中sizeof（int）*100代表你要申请的内存空间的大小（可以自己随意设置）。
8、因为malloc函数的返回值是void*，而p是int*，所以要对返回值进行强制转换。
9、再编写一些代码来判断一下malloc是否申请内存成功，接着按快捷键F5运行，查看输出结果，可以看到内存申请成功。
10、最后，我们还要用free函数释放掉刚申请的内存，防止内存泄露，至此，整个代码编写完成。
mallo函数介绍：
malloc的全称是memory allocation，中文叫动态内存分配，用于申请一块连续的指定大小的内存块区域以void*类型返回分配的内存区域地址，当无法知道内存具体位置的时候，想要绑定真正的内存空间，就需要用到动态的分配内存。
void*类型表示未确定类型的指针。C,C++规定，void*类型可以通过类型转换强制转换为任何其它类型的指针。一般需和free函数配对使用。

malloc函数怎么使用

void *malloc(int size);
说明：malloc 向系统申请分配指定size个字节的内存空间。返回类型是 void* 类型。void* 表示未确定类型的指针。C,C++规定，void* 类型可以强制转换为任何其它类型的指针。
从函数声明上可以看出。malloc 和 new 至少有两个不同: new 返回指定类型的指针，并且可以自动计算所需要大小。比如：int *p;p = new int; //返回类型为int* 类型(整数型指针)，分配大小为 sizeof(int);或：int* parrparr = 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得到指针，在其它操作上保持一致。

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

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是什么？怎么用？

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 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()不会有任何作用。

C语言中怎么使用malloc函数？

malloc只是动态分配内存存储空间。
void *malloc(long nBytes)：该函数分配了nBytes个字节，并返回了指向这块内存的指针。如果分配失败，则返回一个空指针（NULL）
例如：char *Ptr = NULL;
Ptr = (char *)malloc(100 * sizeof(char));
就是这样！当然，具体情况要具体分析以及具体解决。比如说，你定义了一个指针，在一个函数里申请了一块内存然后通过函数返回传递给这个指针，那么也许释放这块内存这项工作就应该留给其他函数了

C语言中的malloc函数用法)？

用变量表示长度，想对数组的大小作动态说明，这是错误的。但是在实际的编程中，往往会发生这种情况，即所需的内存空间取决于实际输入的数据，而无法预先确定。对于这种问题，用数组的办法很难解决。为了解决上述问题，C语言提供了一些内存管理函数，这些内存管理函数可以按需要动态地分配内存空间，也可把不再使用的空间回收待用，为有效地利用内存资源提供了手段。
常用的内存管理函数有以下三个：
1. 分配内存空间函数malloc
调用形式：
(类型说明符*)malloc(size)
功能：在内存的动态存储区中分配一块长度为"size"字节的连续区域。函数的返回值为该区域的首地址。
“类型说明符”表示把该区域用于何种数据类型。
(类型说明符*)表示把返回值强制转换为该类型指针。
“size”是一个无符号数。
例如：
pc=(char *)malloc(100);
表示分配100个字节的内存空间，并强制转换为字符数组类型，函数的返回值为指向该字符数组的指针，把该指针赋予指针变量pc。
2. 分配内存空间函数 calloc
calloc 也用于分配内存空间。
调用形式：
(类型说明符*)calloc(n,size)
功能：在内存动态存储区中分配n块长度为“size”字节的连续区域。函数的返回值为该区域的首地址。
(类型说明符*)用于强制类型转换。
calloc函数与malloc 函数的区别仅在于一次可以分配n块区域。
例如：
ps=(struet stu*)calloc(2,sizeof(struct stu));
其中的sizeof(struct stu)是求stu的结构长度。因此该语句的意思是：按stu的长度分配2块连续区域，强制转换为stu类型，并把其首地址赋予指针变量ps。
2. 释放内存空间函数free
调用形式：
free(void*ptr);
功能：释放ptr所指向的一块内存空间，ptr是一个任意类型的指针变量，它指向被释放区域的首地址。被释放区应是由malloc或calloc函数所分配的区域。
【例】分配一块区域，输入一个学生数据。
main()
{
struct stu
{
int num;
char *name;
char sex;
float score;
} *ps;
ps=(struct stu*)malloc(sizeof(struct stu));
ps->num=102;
ps->name="Zhang ping";
ps->sex='M';
ps->score=62.5;
printf("Number=%d\nName=%s\n",ps->num,ps->name);
printf("Sex=%c\nScore=%f\n",ps->sex,ps->score);
free(ps);
}
本例中，定义了结构stu，定义了stu类型指针变量ps。然后分配一块stu大内存区，并把首地址赋予ps，使ps指向该区域。再以ps为指向结构的指针变量对各成员赋值，并用printf输出各成员值。最后用free函数释放ps指向的内存空间。整个程序包含了申请内存空间、使用内存空间、释放内存空间三个步骤，实现存储空间的动态分配。
可以用，两者的区别在于，一个是创建静态内存，一个是动态内存。
只是你要做成服务程序或者有基于这个数组的算法时，别忘记用完p之后要free()，并且让p=(int*)NULL
void main()
{
int a[5],*p ;
p=a;
p=(int*)malloc(5*sizeof(int)) ;
//此处这样写有问题，根本就没必要动态分配内存，因为p指向的是一个数组，数组已经定义，也就是已经分配了空间，纯粹多余
for(int i=0;i<5;i++) scanf("%d",p++);
free(p);
}
malloc（）是是在内存的动态存储区中分配一个长度为size的连续空间。
当函数未能成功分配存储空间（如内存不足）就会返回一个NULL指针。所以在调用该函数时应该检测返回值是否为
NULL并执行相应的操作
malloc分配的内存是位于堆中的,并且没有初始化内存的内容使用了malloc没有使用free，注意释放内存
p=(int *)malloc(5*sizeof(int)) /*这个也就是说P指向的连续5个空间的首地址*/
for(i=0;i<5;i++) scanf("%d",p++);
用法没 问题，但是问题是。。你最后p指向了 数组的最后，。。
你还要调整p，scanf("%d",(p+i))多好啊
动态申请1维数组，int *a;
a=(int *)malloc(5*sizeof(int)) ;
for(i=0;i<5;i++) scanf("%d",p++);
以后你就可以引用a数组了
第二种用法有点问题，应该这样改一下：
int *arr = (int *)malloc(5 * sizeof(int));
int *p = arr;
int i;
for (i = 0; i < 5; ++i)
scanf("%d", p++);
...
...
free(arr);
C语言中malloc是动态内存分配函数。
函数原型：void *malloc(unsigned int num_bytes)。
参数：num_bytes 是无符号整型，用于表示分配的字节数。
注意：当内存不再使用时，应使用free()函数将内存块释放。函数返回的指针一定要适当对齐，使其可以用于任何数据对象。关于该函数的原型，在以前malloc返回的是char型指针，新的ANSIC标准规定，该函数返回为void型指针，因此必要时要进行类型转换。
实现malloc的方法：
首先我们要确定所采用的数据结构。一个简单可行方案是将堆内存空间以块的形式组织起来，每个块由meta区和数据区组成，meta区记录数据块的元信息（数据区大小、空闲标志位、指针等等）。
数据区是真实分配的内存区域，并且数据区的第一个字节地址即为malloc返回的地址 。

c++中malloc和alloc函数的声明和调用格式以及其功能

为什么要用malloc和alloc？为什么不用new delete操作符，这种是更安全的方式但是你想用我也告诉你malloc的调用如下（返回的指针类型）malloc（申请的空间大小，一般是类型个数×sizeof（类型））；作用：从堆中申请内存共程序使用，就是动态申请内存alloc是从栈中分配内存
void *malloc( size_t size ); C里面没有alloc这个函数吧。char *a = (char*) malloc(1024); //申请1024字节int *b = (int *) malloc(1024 * sizeof(int)); //申请1024个整形数据空间功能就是分配给指针变量内存空间。相应的，使用完毕后，要free(a); free(b);来释放所申请的内存空间，否则会产生内存泄露。
函数malloc()和calloc()都可以用来动态分配内存空间,但两者稍有区别。
malloc()函数有一个参数,即要分配的内存空间的大小:
void *malloc(size_t size);
calloc()函数有两个参数,分别为元素的数目和每个元素的大小,这两个参数的乘积就是要分配的内存空间的大小。
void *calloc(size_t numElements,size_t sizeOfElement);
如
pthread_t *tid;
tid = (pthread_t*)calloc(numthrds, sizeof(pthread_t));
如果调用成功,函数malloc()和函数calloc()都将返回所分配的内存空间的首地址。
函数malloc()和函数calloc()的主要区别是前者不能初始化所分配的内存空间,而后者能。如果由malloc()函数分配的内存空间原来没有被使用过，则其中的每一位可能都是0;反之,如果这部分内存曾经被分配过,则其中可能遗留有各种各样的数据。也就是说，使用malloc()函数的程序开始时(内存空间还没有被重新分配)能正常进行,但经过一段时间(内存空间还已经被重新分配)可能会出现问题。
函数calloc()会将所分配的内存空间中的每一位都初始化为零,也就是说,如果你是为字符类型或整数类型的元素分配内存,那麽这些元素将保证会被初始化为0;如果你是为指针类型的元素分配内存,那麽这些元素通常会被初始化为空指针;如果你为实型数据分配内存,则这些元素会被初始化为浮点型的零。
另外，calloc返回的是一组对象的数组，而malloc返回的是一个对象。使用calloc表明是要使用一个数组。

在CCS的C编程中怎么使用malloc函数

使用malloc需要包含#include

使用方法和在vc下一样，例如

int *p;

p = (Int*)malloc(100*sizeof(int));

不再使用申请的空间后，再释放掉。

free(p);