calloc

The "c" indicates "cleared." The allocated memory is initialised, or cleared. The initialisation value used by calloc is 0.

char *mystrcpy(char *str1, const cahr *str2){ char *tmp = str1; while(str2) { *str1 = *str2; str1++; str2++; } return tmp;}上面的函数是复制字符串2到字符数组1，返回的就是一个字符串指针，这个函数（strcpy）在库函数里有calloc分配内存要包含stdlib.h头文件，使用方法如下： char *p = (char*)calloc(sizeof(char), 3); //分配3个char类型存储空间，p为指向这个存储区首地址的指针，这个函数会把所有动态分配的存储区内容清0。用完了记得free(p);释放空间。

s被分配了一单位float大小的内存。s地址保存了p1与p2的和的值因为数组名字就是其地址的别名，所以a==&a[0]那么s存的值就是a[0]+b[0]==1.1+10.0==11.1所以输出了11.1

一样的啊，因为二维数组的存储在内存里和一维数组形式是一样的，都是顺序的，所以前面的类型对了，后面只要你指定好你要的大小就好了。

（int*）定义其为指针型变量

你在C#用这个函数做什么用呢？如果是为了节省空间，那用using就好了，用完就释放了。

1sizeof(buf)得到的通常是4，它是32位系统中一个指针所占用的字节数。而如果你用sizeof(*buf)得到的大小是buf指针指向的数据的大小，自然就是char的大小，也就是1。C++并不知道你这里的buf是指向一系列char数据的首地址的指针，而只知道它是一个指向以char数据的指针，结果自然就是1了。2因为calloc会自动在申请到的内存后将它们初始化为0，所以不需要memset。换言之calloc=malloc+memset。

主要的不同是malloc不初始化分配的内存，calloc初始化已分配的内存为0。次要的不同是calloc返回的是一个数组，而malloc返回的是一个对象。calloc等于malloc后在memset很可能calloc内部就是一个malloc再来一个memset清0。所以malloc比calloc更高效.

1

变量或方法没有定义，或者名字写错了，或者引用了别个文件中的方法或者全局变量。

其实你并不用担心这个问题。你引用strcpy(char *a , char *b);这个函数的时候，括号里面的都是实参，比如说是strcpy(str1, str2)，你这里如果保证了数组str1[]的长度大于等于数组str2[]的长度的话就不会有问题。

动态去分配内存是为了不浪费内存！不使用动态分配函数的话，系统会随意在堆上开辟一片大小未知的空间，而且不能初始化所分配的内存空间。

根据代码所示，其含义是:1.申请n1数量的int类型的内存空间2.将申请的内存空间的首地址赋值给int指针p我们可以通过操作指针p对申请的动态数组进行数据的赋值和修改操作。要注意的地方是:当我们不需要使用申请的动态数组内存时，请主动释放申请的内存空间，防止运行期间出现内存泄露问题。

实际 上用数组比用动态内存要安全的多，不是特殊需要还是用数组的好。

你说的这些函数是标准c里面的,所以它的使用跟操作系统无关,都可以使用

这是一个C语言中的函数的原型。用于在内存中动态地分配空间，它返回一个指向分配空间的void型指针，并把相应内存初始化为0。如果两个参数中有一个为0，则函数的行为取决于实现了。关于参数：size_t是一个类型，它取决于你所使用的系统，可以是int、unsigned、long等类型；nelem是要求分配单元的个数；elsize是每个单元所占的字节数。

能

你函数传递指针的拷贝。你修改的只是一个局部指针变量的指向，没有修改到外部传入指针的指向。参数要么用双重指针。char**pStr;要么改成返回值。char*mycalloc(){char*strstr=malloc(sizeof(char)*100);memset(str,"a",100);returnstr;}//字符串结尾最好加个

这个是下标溢出的错误，但我检查了你的代码，也没问题，不知道怎么回事我复制你的代码时编译不了，有几个地方得修改，编译过了也没错，能运行，你查到了告诉我一下吧，谢谢了，#include <stdio.h>#include <stdlib.h>#include <string.h>#include <assert.h>#include <math.h>#define PI 3.1415926int halfsine_filter(int *n,float Tc,float **hn,int **len);float p(float t,float Tc);int *len=NULL;float *hn=NULL;void main(){ int n = 30;  int i; float Tc = 0.1; halfsine_filter(&n,Tc,&hn,&len); for (i = 0; i < (*len); i ++) {  printf("hn[%d]=%.4f ",i,hn[i]); } free(hn); hn=NULL; getchar();}int halfsine_filter(int *n,float Tc,float **hn,int **len){ int i; float sum = 0; float *t = (float*)calloc(*n, sizeof(float)); assert(t!=NULL); *hn = (float*)calloc(*n,sizeof(float)); assert((*hn)!=NULL); t[0] = 0; for(i = 1; i < *n; i ++) {  t[i] = t[i-1] + 2 * Tc / (*n-1); } for(i = 0; i < *n; i ++) {  (*hn)[i]=p(t[i],Tc);  sum += (*hn)[i]; } // for( i = 0; i <*n; i ++) {  (*hn)[i] /= sum; } *len=n;//数组的长度  //释放内存 free(t);  return 0; }float p(float t,float Tc){ return (float)sin(PI*t/(2*Tc)); }

bool a[101]={1}; //a[i]表示第i人还活着int n,m,i=0,s=0,t=0;cin>>n>>m; //人数n，报数mdo{i=i%n+1; //数组模拟环状if(a[i])t++; //第i个人还活着则报数if(t==m) //当前报的数是m{s++; //死亡人数+1cout<<i<<" "; //输出被杀人编号a[i]=0; //此处人已死，设置为0t=0; //计数器清零}}while(s!=n); //直到所有人都被杀死为止

先举个例子：某用户需要一个将任意多个整数按大小排序的程序。（在计算机文件夹中，当文件很多时经常用到排序）1。若不用动态分配内存，那就定义一个超大的数组吧！问题是，如果用户不需要那么大，不就浪费了？如果定义的数组还不够大，不就不能满足需求了？2。如果用动态分配，就解决上述问题了。当你需要多大内存时，就给你多大——如果有的话——这就是动态分配的意义。 现在看上述问题的代码，我调试过的：----------------------------------------------------------------------#include <stdio.h>#include <stdlib.h> /* calloc、exit需要声明头文件 */void main(){ int n,*p,i,j,m; printf("本程序可对任意个整数排序; "); printf("请输入整数的总个数: "); scanf("%d",&n); p=(int *)calloc(n,sizeof(int)); /* calloc函数的使用 */ if(p==0) { printf("分配失败! "); exit(1); /* 当分配失败时，exit可以终止程序 */ } printf("请输入这些整数: "); for(i=0;i<n;i++) scanf("%d",p+i); /* 利用指针移位的方法赋值 */ for(i=1;i<n;i++) /* 冒泡排序法 */ { for(j=0;j<n-i;j++) if(*(p+j)>*(p+j+1)) { m=*(p+j); *(p+j)=*(p+j+1); *(p+j+1)=m; } } printf("将这些整数从小到大排列输出为:"); for(i=0;i<n;i++) { if(i%5==0) printf(" "); /* 每隔5个数换行 */ printf(" %11d;",*(p+i)); /* 为了整齐，每个数占11个字符，当数字很多时这很重要 */ } printf(" "); free(p); /* 释放空间 */}---------------------------------------------------------------------- 调用calloc函数时，calloc(n,sizeof(int))表示请求n个连续的、每个长度为整型的空间，若成功返回这些空间的首地址。（int *）表示将这个地址放在指针中。到此为止，就可以用指针来对分配到的空间操作了。注意，最后一定要用free函数释放申请到的空间，否则这部分空间会一直占着。 malloc、calloc、realloc的用法（以上述问题为例）及区别： 1。malloc(n*sizeof(int)) /* 请求n个连续的、每个长度为整型的空间，若成功返回这些空间的首地址，失败返回0 */ 2。calloc(n,sizeof(int)) /* 请求n个连续的、每个长度为整型的空间，若成功返回这些空间的首地址并将每个空间赋值为0，失败返回0 */ 3。realloc(p,sizeof(int)*n) /* 给一个已经分配了地址的指针重新分配空间,参数p为原有的空间地址,sizeof(int)*n是重新申请的地址长度，用于分配不足的时候。个人觉得没用——不够就找到原分配处改大一点不就行了？！ */ 我能说得只有这些了，有些东西看起来麻烦，当你小试一下就会发现，不过如此嘛！学C要多练、多思，不怕麻烦。不知道您学了递归没有？有个经典的“汉诺塔”问题，那家伙——得整死人啊！到现在我还一知半解的…… 希望我的回答对您有帮助！

XP32位操作系统的寻址空间是4GB；不过操作系统保留了其中的2G，可以供应用程序使用的大约还有2G的空间。不过LZ的程序，总共也就分配了(1148928+2652408）*4B,才几十MB，远远小于2GB啊。

程序没问题啊,看你用的是DEV-CPP,用F11编译运行程序先输入一个个数,然后输入个数个数如10 1 2 3 4 5 6 7 8 9 10程序会输出这十个数,然后输出它们的和

s被分配了一单位float大小的内存。s地址保存了p1与p2的和的值因为数组名字就是其地址的别名，所以a==&a[0]那么s存的值就是a[0]+b[0]==1.1+10.0==11.1所以输出了11.1

是malloc()函数通常和free（）配对使用，通常为指针分配储存空间比如char *pp = (char *)malloc(sizeof(char *));在分配后要判断是否成功分配if (p == NULL) printf("Fail to allocate storage: ");

pprimes=(unsigned long long *)calloc((size_t)total,sizeof(unsigned long long));

第24行代码，你都知道fp是NULL，就不要fclose(fp)了

/* * File: main.cpp * Author: Vicky.H * Email: eclipser@163.com */ #include <iostream> #include <cstdlib> #include <memory> class A { public: A() { std::cout << "create A" << std::endl; } A(const A& o) { std::cout << "copy A" << std::endl; } ~A() { std::cout << "delete A" << std::endl; } }; /* * */ int main(void) { char* buf1 = (char*) malloc(10); // char* buf2 = (char*) calloc(1, 10); // 效果虽然与上面一样,不同的是,calloc会将空间初始化为0. free(buf1); free(buf2); std::cout << "---------------------------" << std::endl; // 为什么C++中不建议使用malloc calloc realloc等C语言函数?因为:这样分配的空间,返回的指针需要通过free来释放,但free释放空间不同于delete,free不会执行析构函数! A* ap = (A*) malloc(sizeof (class A) * 10); std::uninitialized_fill_n(ap, 10, A()); free(ap); // 调用1次create A ,1次delete A 10次copy A return 0; }

str=(char **)calloc(m, sizeof(char *));//分配m个char指针for(int i=0;i<m;i++){    str[i] = calloc(1, 100 * sizeof(char));//为每个char指针分配100个char}

x是一个2重指针给numrows分配了一个float的内存，然后用x指向了存放numrows指针地址的空间打个比方执行顺序为numrows 0x0001这个一个字节的内存分配给了numrows，然后x 比方说他的地址是0x0010,这个地址里的值写的就是0x0001，x里存放的是numrows的地址

是分配10个大小为char，也就是十个字节的内存给str，地址类型是char指针str = (char*)calloc(10,sizeof(char));的 (char*)和(char)可以换成其他的比如str = (Int*)calloc(10,sizeof(int));这样写就是分配10x4=40个字节的地址给str

看看这个帖子吧 http://apps.hi.baidu.com/share/detail/5259117

一般申请大的内存时使用:char *string;string = (char *)malloc(256); //申请256字节的字符串free(string); //用完后记得释放内存=======string = (char *)malloc(128);str = realloc(string, 256); //128太小，重新申请256大小。这些用法可以搜索“C库函数大全”，里面有各种库函数的详细用法和举例

动态申请空间 ，注意用free释放空间

内存分配的

calloc == clear allocate

函数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得到指针，在其它操作上保持一致。

这句话的意思是动态分配一个float大小的内存空间，把这块空间的首地址传给一个浮点数指针型的变量s。calloc是一个ISOC函数。函数名：calloc函数原型：void*calloc(size_tn,size_tsize)；功能：在内存的动态存储区中分配n个长度为size的连续空间，函数返回一个指向分配起始地址的指针；如果分配不成功，返回NULL。sizeof的概念　　sizeof是C语言的一种单目操作符，如C语言的其他操作符++、--等。它并不是函数。sizeof操作符以字节形式给出了其操作数的存储大小。操作数可以是一个表达式或括在括号内的类型名。操作数的存储大小由操作数的类型决定。sizeof的使用方法　　1、用于数据类型　　sizeof使用形式：sizeof（type）　　数据类型必须用括号括住。如sizeof（int）。　　2、用于变量　sizeof使用形式：sizeof（var_name）或sizeofvar_name　　变量名可以不用括号括住。如sizeof(var_name)，sizeofvar_name等都是正确形式。带括号的用法更普遍，大多数程序员采用这种形式。

malloc是一次分配地址，calloc是经过malloc分配地址不够用了，再在malloc已经分配的地址空间的基础上追加参数那么大的地址~~~

calloc是一个iosc函数　　函数名：calloc　　函数原型：void*calloc(size_tn,size_tsize)；　　功能：在内存的动态存储区中分配n个长度为size的连续空间，函数返回一个指向分配起始地址的指针；如果分配不成功，返回null。　　用法:　　void*calloc(size_tn,size_tsize)；　　一般使用后要使用 free(起始地址的指针)对内存进行释放，不然内存申请过多会影响计算机的性能，以至于得重启电脑。如果使用过后不清零，还可以使用指针对该块内存进行访问。　　头文件：stdlib.h或malloc.h　　相关函数：malloc、realloc、free _alloca

float *p;int m;scanf("%d",&m);if((p=(float *)calloc(m,sizeof(float)))==NULL) { printf("No space available. "); exit(1); }folat *q = p;while (q != p+m){ //*q++ = 3.14 对数组空间赋值 }q = p;while (q != p+m){ //*q++ 遍历数组}利用指针的移动进行赋值或取值!关键是对指针的操作要搞清楚!

首先要理解int* ptr = (int*)malloc(5 * sizeof(int)); // 动态分配5个整型的内存空间，跟int a[5]相似，但前者是堆上分配的，后者是栈上分配的p=(int **)malloc(sizeof(int*)*5); // 意思就是定义一个有5个int类型的指针的动态数组，然后在里面存放指针p[i] 其实就是一个指针p[i]=(int *)malloc(sizeof(int)*5); // 给该指针分配内存

sizeof(reference)? i guess it"s wrong .maybe u need add the size of the content together,

是的，malloc和calloc函数都是向内存申请一定大小的空间，如果内存分配成功则返回指向被分配内存的指针(此存储区中的初始值不确定)，否则返回空指针NULL。

#include <stdio.h>int main(){int *p = (int*)calloc(10, sizeof(int));if (NULL == p){ free(p); fprintf(stderr, "Fail to calloc mem!"); return -1;}else{//use p as you wish//don"t forget to free p at last!!!!!}return 0;}

其实你成功分配的只有p[0]-p[9]，但是你取其他的index，只是在原来的地址上往后移，那些位置上的值是随机的，没有实际意义。

你应该深入阅读一些C语言指针与数组方面的教材，在C中，数组和指针在某种意义上说是等价的，数组和指针都可以通过下标来访问例如，在声明函数a()时，int a(int *b);与int a(int b[]);是等价的

给一个指针分配内存，使用结束后，必须释放掉。如果不释放，会造成内存泄漏。例如： char*str = NULL; /*分配内存空间*/ str = (char*)calloc(10,sizeof(char)); str = (char*)calloc(20,sizeof(char));//此处再次分配了一次空间，但没有释放前面申请的空间，造成了10字节的内存泄漏。 free(str);

空间内部当然是连续的，但是两次calloc分配的空间之间就不连续了。

//一个例子。typedef struct tagData{int v;struct tagData* next;}Data;int i,n=6;Data* pt=(Data*)calloc(n,sizeof(Data));for(i=0;i<n-1;i++)//看这pt[i].next=pt+i+1;//令最后一个节点的next为NULLpt[n-1].next=NULL;

w[i] = calloc(strlen(word) + 1, sizeof(char)); 改为：w[i] = (char *)calloc(strlen(word) + 1, sizeof(char));

calloc的函数原型是void *calloc(unsigned n,unsigned size); free的函数原型是void free(void *p);

这句话的意思是动态分配一个float大小的内存空间，把这块空间的首地址传给一个浮点数指针型的变量s。calloc是一个ISOC函数。函数名：calloc函数原型：void*calloc(size_tn,size_tsize)；功能：在内存的动态存储区中分配n个长度为size的连续空间，函数返回一个指向分配起始地址的指针；如果分配不成功，返回NULL。sizeof的概念　　sizeof是C语言的一种单目操作符，如C语言的其他操作符++、--等。它并不是函数。sizeof操作符以字节形式给出了其操作数的存储大小。操作数可以是一个表达式或括在括号内的类型名。操作数的存储大小由操作数的类型决定。sizeof的使用方法　　1、用于数据类型　　sizeof使用形式：sizeof（type）　　数据类型必须用括号括住。如sizeof（int）。　　2、用于变量　sizeof使用形式：sizeof（var_name）或sizeofvar_name　　变量名可以不用括号括住。如sizeof(var_name)，sizeofvar_name等都是正确形式。带括号的用法更普遍，大多数程序员采用这种形式。

*表示指针，(void*)表示函数返回void类型的指针unsigned表示无符号整型，unsigned n, unsigned size定义了n,size为无符号整型变量

malloc与calloc没有本质区别，malloc之后的未初始化内存可以使用memset进行初始化。主要的不同是malloc不初始化分配的内存，calloc初始化已分配的内存为0。次要的不同是calloc返回的是一个数组，而malloc返回的是一个对象。calloc等于malloc后在memset很可能calloc内部就是一个malloc再来一个memset清0。所以malloc比calloc更高效。分配内存空间函数malloc 调用形式: (类型说明符*) malloc (size) 。分配内存空间函数 calloc calloc 也用于分配内存空间。

请问你的问题解决了吗？我也遇到了同样的问题。

calloc和malloc 功能基本一样都是申请连续内存空间，返回首地址指针。区别就是calloc自带了初始化为零，而malloc申请后，需要人为初始化值。和数据结构的拷贝没有任何直接关系！原型：void *calloc(unsigned n,unsigned size)；我写了个简单的插入链表，你参考吧#include <stdio.h>#include <stdlib.h>typedef struct student_list{    char name[6];    struct student_list *next;}SL;void insertSL(SL *slHead);//添加结构数据到链表  参数：头节点指针int main(void){    SL *slHead=(SL *)calloc(1,sizeof(SL));//头节点指针不存放数据，用于遍历    slHead->next=NULL;    insertSL(slHead);//想插入几个，就调用几次    insertSL(slHead);    insertSL(slHead);    insertSL(slHead);    while(slHead->next!=NULL)//打印    {        printf("%s ",slHead->next->name);        slHead=slHead->next;    }    return 0;}void insertSL(SL *slHead){    SL *slNew=(SL *)calloc(1,sizeof(SL));    printf("请输入节点名称：");    scanf("%s",slNew->name);    while(slHead->next!=NULL)        slHead=slHead->next;    slHead->next=slNew;}

主要的不同是malloc不初始化分配的内存，calloc初始化已分配的内存为0。次要的不同是calloc返回的是一个数组，而malloc返回的是一个对象。calloc等于malloc后在memset很可能calloc内部就是一个malloc再来一个memset清0。所以malloc比calloc更高效.

内存空间为零的意思是,calloc所分配的这块内存,其内容全部填为零.我们来谈谈另外一个函数,malloc,这个函数在分配完内存后,所分配的内存地址里面是有内容的,这些内容是上一次分配使用的内容,是一些垃圾内容,操作系统为了效率,不会自动把这些内容清空(清空也就是把内容全部填为零),而由程序员根据需要自己把其清空.calloc 等效于 malloc + memset.没有calloc的情况下,程序员如果想要一块干净的内存,必须先用malloc取得一块内存,然后用memset把内容清空.有了calloc后,程序员只需要调用calloc就可以得到一块干净的内存,不需要再调用memset把内容清空了.那既然有了calloc,为何还需要malloc呢? 那是因为很多时候程序员并不需要一块干净的内存,这个时候调用malloc的效率就会比calloc高.

malloc与calloc没有本质区别，malloc之后的未初始化内存可以使用memset进行初始化。主要的不同是malloc不初始化分配的内存，calloc初始化已分配的内存为0。次要的不同是calloc返回的是一个数组，而malloc返回的是一个对象。calloc等于malloc后在memset很可能calloc内部就是一个malloc再来一个memset清0。所以malloc比calloc更高效。分配内存空间函数malloc 调用形式: (类型说明符*) malloc (size) 。分配内存空间函数 calloc calloc 也用于分配内存空间。

calloc将分配的内存空间初始化为0。但是ANSI C并不保证0值与浮点0或空指针的值相同。函数简介 函数名: calloc 功 能: 分配主存储器,分配内存的大小为nelem*elsize，并将其初始化为0（如果是浮点数，则小数点后0的个数视格式而定）。即给一个数组开辟内存空间，并给数组中的每个元素赋初值0。 用 法: void *calloc(size_t nelem, size_t elsize); 头文件：stdlib.h或malloc.h 相关函数：malloc、realloc、free应用举例 程序例1: #include <stdlib.h> #include<string.h> #include <stdio.h> int main(void) { char *str = NULL; /* 分配内存空间 */ str = (char*)calloc(10, sizeof(char)); /* 将hello写入*/ strcpy(str, "Hello"); /*显示变量内容*/ printf("String is %s ", str); /* 释放空间 */ free(str); return 0; } 程序例2： 从这个例子可以看出calloc分配完存储空间后将元素初始化。 #include<stdio.h> #include<stdlib.h> int main(void) { int i; int *pn=calloc(10,sizeof(int)); for(i=0;i<10;i++) printf("%3d",pn[i]); printf(" "); free(pn); return 0; } 输出十个0。

这是申请内存的函数，存在与头文件stdlib.h中，malloc的使用方法最简单接下来是例子：#include<stdlib.h>#include<stdio.h>main(){int*m;m=(int*)malloc(sizeof(int)*16);//这里每次在使用malloc的时候前面要加一个强制类型转换，转换到你需要的类型，后面的括号内就是申请的大小，我这例子是申请的16个整数型大小内存代表这个M可以当数组用了m[11]=8899;printf("%d",m[11]);free(m);//记得每次申请后都需要释放内存，不然会造成浪费影响计算机运行速度}calloc是申请后自动将申请的内存全都初始化为0举个例子：#include<stdio.h>#include<stdlib.h>main(){int*m;m=(int*)calloc(16,sizeof(int));//是不是感觉差不多就是把*改成了，而已printf("%d",m[10]);//这个肯定是0free(m);}将他们的原型放在这里void*malloc(intsize); void*calloc(intnumber,intsize);size代表大小，number代表个数

void *malloc(unsigned int num_bytes);功能：分配长度为num_bytes字节的内存块malloc()------------------------------------------- malloc()函数用来分配内存：将总共需要的字节数作为参数传递给该函数，返回值是指向最新分配的内存的指针，而如果内存没有分配好，则返回值是NULL。malloc()的使用技术： some_type *pointer; pointer = malloc(count * sizeof(*pointer));注：(1) 这个方法保证malloc()会分配正确数量的内存，而不用考虑pointer的生命。如果pointer的类型后来变了，sizeof算子自动确保要分配的字节数仍然正确。(2) malloc()返回的内存是“没有“初始化的。这块内存可能包含任何随机的垃圾，你可以马上用有效数据或者至少是用零来初始化这块内存。要用0初始化，可以用void *memset(void *s, int c, size_t n);(3) malloc()最终通过缺页异常获取的物理内存中的原有数据，大多数情况下是0(但不能保证一定是0)void *calloc(size_t nelem, size_t elsize);功 能: 分配主存储器,分配内存的大小为nelem*elsize，并将其初始化calloc()------------------------- calloc()函数是malloc的简单包装。它的主要优点是把动态分配的内存清零。 void *calloc(size_t nmemb, size_t size); 用经验的程序员更喜欢使用calloc()，因为这样的话新分配内存的内容就不会有什么问题，调用calloc()肯定会清0，并且可以避免调用memset().

#include <stdio.h>#include <stdlib.h>struct content{ char id[100]; char bookname[100]; char editorname[100]; char publishname[100]; struct content *next;};int main(){ FILE *fp;///读文件用的文件指针 char root[1000];///记录文件所在的目录 scanf("%s",root);///输入文件所在的目录 fp=fopen(root,"r");///打开文件 if (fp==NULL)///如果文件指针为空，报错 { printf("无法打开文件! "); return 0; } struct content *p1,*p2=NULL; p1=(struct content*)calloc(1,sizeof(struct content)); p2=p1; while (fscanf(fp,"%s",p1->id)==-1) { fscanf(fp,"%s",p1->bookname); fscanf(fp,"%s",p1->editorname); fscanf(fp,"%s",p1->publishname); p2->next=p1; p2=p1; p2->next=NULL; p1=(struct content*)calloc(1,sizeof(struct content)); } return 0;}这是代码，没测试过，不知道对吧，高手不敢当，希望对你有用

你是这样考虑的吧：main函数调用 fun函数 然后通过参数传递，指针p1指向a[0]=1.1。指针p2指向b[0]=10.0。所以结果是11.1。你没搞清楚变量的作用域问题。fun函数中的形式参数s是局部变量。它的作用域仅仅局限于fun函数内部。在main函数调用fun函数之后，fun函数中的s所占用的内存就已经释放了。所以printf函数中的参数列表中的s指的是main函数中的指针变量s。而该变量一直指向a[0]=1.1 所以结果是1.10。而不是11.10

函数原型：void* realloc(void* ptr, unsigned newsize);void* malloc(unsigned size);void* calloc(size_t nelem, size_t elsize);函数声明都在stdlib.h函数库内。 malloc调用形式为(类型*)malloc(size)：在内存的动态存储区中分配一块长度为"size"字节的连续区域，返回该区域的首地址。 calloc调用形式为(类型*)calloc(n，size)：在内存的动态存储区中分配n块长度为"size"字节的连续区域，返回首地址。 realloc 不能保证重新分配后的内存空间和原来的内存空间指在同一内存地址, 它返回的指针很可能指向一个新的地址。所以，在代码中，必须把realloc返回的值，重新赋给 p 如:p = (char *) realloc (p, old_size + new_size);甚至可以传一个空指针（0）给 realloc ，则此时realloc 作用完全相当于malloc。如：int* p = (char *) realloc (0,old_size + new_size);　//全新分配一个内存空间，作用完全等同于以下这行：　 int* p = (char *) malloc(old_size + new_size);calloc(len, size)与malloc相似,参数len为申请地址的单位元素长度,size为元素个数,如:char* p;p=(char*)calloc(sizeof(char),1000);另外：void *alloca(size_t size)函数说明：alloca()用来配置size个字节的内存空间，然而和malloc/ calloc不同的时， alloca()是从堆栈空间(stack)中配置内存，因此在函数返回时会自动释放此空间返回值 ：若配置成功则返回一指针， 失败则返回NULL

直接搜索"calloc full name"就是答案，既然说到了顺便帮你们都查一下。malloc —— memory allocation 内存分配calloc —— contiguous allocation 连续分配realloc —— re-allocation 重分配

void *calloc(size_t nobj, size_t size)；calloc函数为由nobj个长度为size的对象组成的数组分配内存，并返回指向分配区域的指针；若无法满足要求，则返回NULL。该空间的初始长度为0字节 void *malloc(size_t size)；malloc函数为长度size的对象分配内存，并返回指向分配区域的指针；若无法满足要求，则返回NULL。该函数不对分配的内存区域进行初始化。 void *realloc(void *p, size_t size)；realloc函数将p指向的对象的长度修改为size个字节。如果新分配的内存比原来内存大，则内存的内容保持不变，增加的空间不进行初始化。如果新分配的内存比原来的内存小，则分配内存单元不初始化，realloc函数返回指向新分配空间的指针；若无法满足要求，则返回NULL。在这种情况下，原来指针p指向的单元内容保持不变。str = (char*)calloc(10,sizeof(char));是什么意思？是分配10个大小为char，也就是十个字节的内存给str，地址类型是char指针

楼主试下*(p+N)来访问，如果不行，应该就是*(p+N*sizeof(float))来访问，这应该和数组指针的访问方式相类似的。这个函数是分配内存用的，分配的方式应该和数组一样的。优点在于数组初始化的时候必须制定下标，也就是数组出初始化的大小是固定的，而calloc可以动态分配。

“malloc()和calloc()的区别: malloc()和calloc()的功能都是在内存的动态存储区中分配n个长度为size的连续空间,函数返回一个指向分配起始地址的指针。 而他们之间的区别就是calloc在动态分配完内存后,自动初始化该内存空间为零,而malloc不初始化,里边...”

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。简单的说是：malloc它允许从空间内存池中分配内存,malloc()的参数是一个指定所需字节数的整数.例如:P=(int*)malloc(n*sizeof(int)); colloc与malloc类似,但是主要的区别是存储在已分配的内存空间中的值默认为0,使用malloc时,已分配的内存中可以是任意的值. colloc需要两个参数,第一个是需要分配内存的变量的个数,第二个是每个变量的大小.例如:P=(int*)colloc(n,colloc(int));