转几篇malloc和calloc的文章

malloc和calloc(转载)

引自：

http://blog.chinaunix.net/u/19441/showart_269118.html

来源：

http://zhidao.baidu.com/question/8581040.html

函数malloc()和calloc()都可以用来动态分配

内存空间,但两者稍有区别。

malloc()函数有一个参数,即要分配的内存空间

的大小:

void *malloc(size_t size);

calloc()函数有两个参数,分别为元素的数目和

每个元素的大小,这两个参数的乘积就是要分配

的内存空间的大小。

void *calloc(size_t numElements,size_t

sizeOfElement);

如果调用成功,函数malloc()和函数calloc()都

将返回所分配的内存空间的首地址。

函数malloc()和函数calloc()的主要区别是前

者不能初始化所分配的内存空间,而后者能。如

果由malloc()函数分配的内存空间原来没有被

使用过，则其中的每一位可能都是0;反之,如果

这部分内存曾经被分配过,则其中可能遗留有各

种各样的数据。也就是说，使用malloc()函数

的程序开始时(内存空间还没有被重新分配)能

正常进行,但经过一段时间(内存空间还已经被

重新分配)可能会出现问题。

函数calloc()会将所分配的内存空间中的每一

位都初始化为零,也就是说,如果你是为字符类

型或整数类型的元素分配内存,那麽这些元素将

保证会被初始化为0;如果你是为指针类型的元

素分配内存,那麽这些元素通常会被初始化为空

指针;如果你为实型数据分配内存,则这些元素

会被初始化为浮点型的零。


需要包含头文件：
＃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得到指针，在其它操作上保持一致。
参考资料：

http://zhidao.baidu.com/question/4506780.html

http://www.englishfree.com.cn/schoolfree/cn/computer/text/c/011-22.htm

原文地址

http://zhidao.baidu.com/question/8581040.html

 

 

 

来源地址：

http://club.topsage.com/thread-2388900-1-1.html

 

malloc()与calloc()

    C语言跟内存分配方式
    1） 从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static变量。

    2） 在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。

    3）从堆上分配，亦称动态内存分配。程序在运行的时候用malloc或new申请任意多少的内存，程序员自己负责在何时用free或delete释放内存。

         动态内存的生存期由我们决定，使用非常灵活，但问题也最多C语言跟内存申请相关的函数主要有 alloca,calloc,malloc,free,realloc,sbrk等.

         其中alloca是向栈申请内存,因此无需释放.

         malloc分配的内存是位于堆中的,并且没有初始化内存的内容,因此基本上malloc之后,调用函数memset来初始化这部分的内存空间.

         calloc则将初始化这部分的内存,设置为0.

         而realloc则对malloc申请的内存进行大小的调整.申请的内存最终需要通过函数free来释放. 而sbrk则是增加数据段的大小;

         malloc/calloc/free基本上都是C函数库实现的,跟OS无关.C函数库内部通过一定的结构来保存当前有多少可用内存.如果程序 malloc的大小超出了库里所留存的空间,那么将首先调用brk系统调用来增加可用空间,然后再分配空间.free时,释放的内存并不立即返回给os, 而是保留在内部结构中. 可以打个比方: brk类似于批发,一次性的向OS申请大的内存,而malloc等函数则类似于零售,满足程序运行时的要求.这套机制类似于缓冲.使用这套机制的原因: 系统调用不能支持任意大小的内存分配(有的系统调用只支持固定大小以及其倍数的内存申请,这样的话,对于小内存的分配会造成浪费; 系统调用申请内存代价昂贵,涉及到用户态和核心态的转换.

 

 函数malloc()和calloc()都可以用来分配动态内存空间，但两者稍有区别。      
    malloc()函数有一个参数，即要分配的内存空间的大小：       
    Void *malloc(size_t size);      
    calloc()函数有两个参数，分别为元素的数目和每个元素的大小，这两个参数的乘积就是要分配的内存空间的大小：       
    void *calloc(size_t numElements，size_t sizeOfElement)；
    如果调用成功，函数malloc()和calloc()都将返回所分配的内存空间的首地址。   

    malloc() 函数和calloc ()函数的主要区别是前者不能初始化所分配的内存空间，而后者能。

    如果由malloc()函数分配的内存空间原来没有被使用过，则其中的每一位可能都是 0；反之，如果这部分内存空间曾经被分配、释放和重新分配，则其中可能遗留各种各样的数据。也就是说，使用malloc()函数的程序开始时(内存空间还没有被重新分配)能正常运行，但经过一段时间后(内存空间已被重新分配)可能会出现问题。   

    calloc() 函数会将所分配的内存空间中的每一位都初始化为零，也就是说，如果你是为字符类型或整数类型的元素分配内存，那么这些元素将保证会被初始化为零；如果你是为指针类型的元素分配内存，那么这些元素通常(但无法保证)会被初始化为空指针；如果你是为实数类型的元素分配内存，那么这些元素可能(只在某些计算机中)会被初始化为浮点型的零。   

    malloc() 函数和calloc ()函数的另一点区别是calloc()函数会返回一个由某种对象组成的数组，但malloc()函数只返回一个对象。为了明确是为一个数组分配内存空间，有些程序员会选用calloc()函数。但是，除了是否初始化所分配的内存空间这一点之外，绝大多数程序员认为以下两种函数调用方式没有区别：calloc(numElements ，sizeOfElement)；    malloc(numElements *sizeOfElement) ；    需要解释的一点是，理论上(按照ANSIC标准)指针的算术运算只能在一个指定的数组中进行，但是在实践中，即使C编译程序或翻译器遵循这种规定，许多C程序还是冲破了这种限制。因此，尽管malloc()函数并不能返回一个数组，它所分配的内存空间仍然能供一个数组使用(对realloc()函数来说同样如此，尽管它也不能返回一个数组)。   

    总之，当你在calloc()函数和malloc()函数之间作选择时，你只需考虑是否要初始化所分配的内存空间，而不用考虑函数是否能返回一个数组。

    当程序运行过程中malloc了,但是没有free的话,会造成内存泄漏.一部分的内存没有被使用,但是由于没有free,因此系统认为这部分内存还在使用,造成不断的向系统申请内存,是的系统可用内存不断减少.但是,内存泄漏仅仅指程序在运行时,程序退出时,OS将回收所有的资源.因此,适当的重起一下程序,有时候还是有点作用.

 

malloc函数来源地址：

http://blog.tianya.cn/blogger/post_show.asp?BlogID=1672669&PostID=13428340

 
　　
　　原型：extern void *malloc(unsigned int num_bytes);
　　
　　 用法：#include
　　
　　 功能：分配长度为num_bytes字节的内存块
　　
　　 说明：如果分配成功则返回指向被分配内存的指针，否则返回空指针NULL。
　　 当内存不再使用时，应使用free()函数将内存块释放。
　　
　　 举例：
　　 // malloc.c
　　
　　 #include
　　 #include
　　 main()
　　 {
　　 char *p;
　　
　　 clrscr(); // clear screen
　　 p=(char *)malloc(100);
　　 if(p)
　　 printf("Memory Allocated at: %x",p);
　　 else
　　 printf("Not Enough Memory!\n");
　　 free(p);
　　
　　 getchar();
　　 return 0;
　　 }
　　
　　函数声明(函数原型)：
　　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得到指针，在其它操作上保持一致。

　　
　　
　　函数名: calloc
　　
　　功 能: 分配主存储器

　　用 法: void *calloc(size_t nelem, size_t elsize);
　　程序例:
　　
　　#include
　　#include
　　
　　int main(void)
　　{
　　 char *str = NULL;
　　
　　 /* allocate memory for string */
　　 str = calloc(10, sizeof(char));
　　
　　 /* copy "Hello" into string */
　　 strcpy(str, "Hello");
　　
　　 /* display string */
　　 printf("String is %s\n", str);
　　
　　 /* free memory */
　　 free(str);
　　
　　 return 0;
　　}
　　
　　realloc
　　
　　 原型：extern void *realloc(void *mem_address, unsigned int newsize);
　　
　　 用法：#include
　　
　　 功能：改变mem_address所指内存区域的大小为newsize长度。
　　
　　 说明：如果重新分配成功则返回指向被分配内存的指针，否则返回空指针NULL。
　　 当内存不再使用时，应使用free()函数将内存块释放。
　　
　　 举例：
　　
　　 // realloc.c
　　
　　 #include
　　 #include
　　
　　 main()
　　 {
　　 char *p;
　　
　　 clrscr(); // clear screen
　　
　　 p=(char *)malloc(100);
　　 if(p)
　　 printf("Memory Allocated at: %x",p);
　　 else
　　 printf("Not Enough Memory!\n");
　　
　　 getchar();
　　
　　 p=(char *)realloc(p,256);
　　 if(p)
　　 printf("Memory Reallocated at: %x",p);
　　 else
　　 printf("Not Enough Memory!\n");
　　
　　 free(p);
　　
　　 getchar();
　　 return 0;
　　 }
　　
　　
　　
　　三个函数的申明分别是:
　　void* realloc(void* ptr, unsigned newsize);
　　void* malloc(unsigned size);
　　void* calloc(size_t numElements, size_t sizeOfElement);
　　都在stdlib.h函数库内
　　它们的返回值都是请求系统分配的地址,如果请求失败就返回NULL
　　
　　malloc用于申请一段新的地址,参数size为需要内存空间的长度,如:
　　char* p;
　　p=(char*)malloc(20);
　　
　　calloc与malloc相似,参数sizeOfElement为申请地址的单位元素长度,numElements为元素个数,如:
　　char* p;
　　p=(char*)calloc(20,sizeof(char));
　　这个例子与上一个效果相同
　　
　　realloc是给一个已经分配了地址的指针重新分配空间,参数ptr为原有的空间地址,newsize是重新申请的地址长度
　　如:
　　char* p;
　　p=(char*)malloc(sizeof(char)*20);
　　p=(char*)realloc(p,sizeof(char)*40);
　　
　　注意，这里的空间长度都是以字节为单位。
　　
　　C语言的标准内存分配函数：malloc，calloc，realloc，free等。
　　malloc与calloc的区别为1块与n块的区别：
　　malloc调用形式为(类型*)malloc(size)：在内存的动态存储区中分配一块长度为“size”字节的连续区域，返回该区域的首地址。
　　calloc调用形式为(类型*)calloc(n，size)：在内存的动态存储区中分配n块长度为“size”字节的连续区域，返回首地址。
　　realloc调用形式为(类型*)realloc(*ptr，size)：将ptr内存大小增大到size。
　　free的调用形式为free(void*ptr)：释放ptr所指向的一块内存空间。
　　C++中为new/delete函数。