精华内容
下载资源
问答
  • realloc和malloc和calloc的区别和用法(个人学习笔记) 思路:先讲下realloc malloc 和 calloc 有啥用法 有一点需要说明的是,他们都是用来开辟内存空间的,其中malloc是在栈区中分配一个内存空间,calloc与realloc...

    realloc和malloc和calloc的区别和用法(个人学习笔记)

    思路:先讲下realloc  malloc  和 calloc 有啥用法

    有一点需要说明的是,他们都是用来开辟内存空间的,其中malloc是在栈区中分配一个内存空间,calloc与realloc都

    是在堆区中分配内存的。访问栈中的内存一般都会比堆区的快,但是有一点是,栈区的内存容量是比较小的,因此要

    注意栈区的内存溢出等问题和越界等问题。

     

    在我们学习的时候一般都是先接触的是malloc  然后再接触calloc和realooc

    所以思路:malloc -- > calloc --->realloc 

     

    malloc

    原型:void* malloc(unsigned size); void* calloc(size_t nelem, size_t elsize); 
    用法:#include <stdlib.h> 
    功能:在堆区开辟一个可控的内存
    说明:size 为需要分配的内存空间的bai大小,以字节(Byte)计。如果重新分配成功则返回指向被分配内存的指针,否则返回空指针NULL。 
    当内存不再使用时,应使用free()函数将内存块释放。 
    注意:这个是开辟的是一个新的未初始化的内存,要注意初始化和赋值

    #include <stdio.h>
    #include <windows.h>
    
    
    void TextMalloc()
    {								/*由于malloc 返回的是void*类型 或者  unsigned int 类型*/ 
    	int * p = (int*)malloc(10*sizeof(int)) ;  // 在这里申请使用内存,(int*)转换成int*类型 
    	int i;
    	for (i = 1; i< 10;i++)
    	{
    		p[i] = i;
    		printf("%d\n",p[i]);
    	}
    	
    	
    	free(p);
    }
    
    int main(void) 
    {
    	
    	TextMalloc();
    	
    	system("pause");
    }

    用malloc的时候要注意的几点是:

    1.返回的是开辟空间的首地址

    2.返回的类型是void* 类型  ,可以随便转换类型,所以灵活使用,使用完要返还给内存,用free函数

    3.不仅能开辟常用类型(int char double等),还能开辟组合类型(结构体等)

    4.申请不一定成功,该函数申请失败返回NULL,故判断空间指向指针为NULL是申请不成功,不能使用   // 可以以下代码用来检测

    	if (p != NULL)
    	{
    		free(p);
            printf("OK\n");
    	 } 

    5.即使我们用了free函数将指针所指向空间释放了,但是指针还保留有开辟空间的起始地址,当我们进行解引用时,就会产生指针所指空间不属于自己,但我们去使用了,导致一些未知性错误(free后指针置NULL)

    	if (p != NULL)
    	{
    		free(p);
    		printf("OK\n");
    	 } 
    	p = NULL ; // 置空 

    6.动开辟的空间是连续的,同数组一样使用,都要防止越界访问      如下

    void Text() 
    {
    
        int* p=(int *)malloc(10*sizeof(int));
        int i=0;
        for(i=0;i<10;i++)
        {
        *(p+i)=i;
        }
        if(p==NULL)
        {
            printf("%s\n",strerror(errno));
            exit(1);
        }
        free(p);
        p=NULL;
        if(p==NULL)
        {
            printf("%s\n",strerror(errno));
            exit(1);
        
    }
    }
    
    int main(void) 
    {
    	
    	// TextMalloc();
    	Text();
    	
    	
    	system("pause");
    }

    calloc

    1.函数原型:void *calloc( size_t num, size_t size );

    2。malloc 的注意事项也同样适用(如上),只不过calloc多了一个参数size_t num,

    还有一个就是calloc分配了内存之后会将所分配的内存空间置零。(和malloc相比省

    去了一个menset()函数)

    int* p=(int *)calloc(10,sizeof(int));    // 前面的10是分配的个数,后面的是分配的大小
    
    char* cp=(char*)=calloc(100,sizeof(char));

    其他的就和malloc一样的啦

    realloc 
    原型:extern void *realloc(void *mem_address, unsigned int newsize); 
    用法:#include <stdlib.h> 有些编译器需要#include <alloc.h> 
    功能:改变mem_address所指内存区域的大小为newsize长度。 
    说明:如果重新分配成功则返回指向被分配内存的指针,否则返回空指针NULL。 
    当内存不再使用时,应使用free()函数将内存块释放。 
    注意:这里原始内存中的数据还是保持不变的。 

    由于个人的表述能力不行,附上一个大牛 的解释

    1、如果有足够空间用于扩大mem_address指向的内存块,则分配额外内存,并返回mem_address 
    这里说的是“扩大”,我们知道,realloc是从堆上分配内存的,当扩大一块内存空间时, realloc()试图直接从堆上现存的数据后面的那些字节中获得附加的字节,如果能够满足,自然天下太平。也就是说,如果原先的内存大小后面还有足够的空闲空间用来分配,加上原来的空间大小= newsize。那么就ok。得到的是一块连续的内存。 
    2、如果原先的内存大小后面没有足够的空闲空间用来分配,那么从堆中另外找一块newsize大小的内存。 
    并把原来大小内存空间中的内容复制到newsize中。返回新的mem_address指针。(数据被移动了)。 
    老块被放回堆上。 

    具体的代码就是这样子的

    // realloc.c 
    #include <syslib.h> 
    #include <alloc.h> 
    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; 
    } 
    #include <malloc.h> 
    char *p,*q; 
    p = (char * ) malloc (10); 
    q=p; 
    p = (char * ) realloc (p,20); 

    // 这里我要进行补充的是 

    relloc 和 malloc 返回都是void * 类型,但是realooc需要一个类型转换(这一点和malloc有点不一样,malloc在有的编译器里会自动给你进行类型转换)

    在一位CSDN大佬(我的算不算)的文章中一小段摘要中:

    #include <stdio.h> 
    #include <string.h>
    #include <stdlib.h>
    #include <windows.h>
    
    /*realloc原型是extern void *realloc(void *mem_address, unsigned int newsize);*/
    /*指针名=(数据类型*)realloc(要改变内存大小的指针名,新的大小)。*/
    void TextRelloc()
    {
    	int aaa ;
    	int *num3 = (int*)malloc(sizeof aaa);
    	int i ;
    	for (i = 0;i< 10;i++)
    	{
    		num3[i] = i;
    	}
    	int *num = (int*)realloc(num3,10*sizeof(char));
    	for (i = 0;i< 10;i++)
    	{
    		printf("%d\n",num3[i]);		/*得到的结果是0 但是要知道,malloc是不会置于0的*/ 
    	}
    	free(num3);
     } 
     
    /*malloc 和 calloc 都是在栈区分配空间的,relloc是在堆区分配空间的*/
    
    int main(void)
    {	
        TextRelloc();
    	
    	
    	system("pause");
    }

    假设整个堆其中都没有不论什么一处的内存可以满足realloc的需求。则此次分配失败,返回值为NULL。,可以看到我给定的内存空间太大导致分配不成功,后面的代码失效

    展开全文
  • void *malloc ( size_t size );  void free ( void *pointer );... calloc和reallocmalloc的区别  calloc和realloc的原型如下:  void *calloc ( size_t num_elements, size_t element_size );  vo...

         void *malloc ( size_t size );

         void free ( void *pointer );

        calloc和realloc与malloc的区别

         calloc和realloc的原型如下:

         void *calloc ( size_t num_elements, size_t element_size );

         void *realloc (void *ptr, size_t new_size );

         calloc和malloc 主要的区别在于前者在返回内存的指针之前将它初始化为0,另外它们请求数量的方式不同。calloc的参数包括所需元素的数量和每个元素的字节,根据这些值可以计算出总共需要分配的内存空间(num_elements*element_size)个字节。

         realloc函数用于修改一个原先已经分配的内存块的大小,可以使一块内存的扩大或缩小。当起始空间的地址为空,即*ptr = NULL,则同malloc。当*ptr非空:若nuw_size < size,即缩小*ptr所指向的内存空间,该内存块尾部的部分内存被拿掉,剩余部分内存的原先内容依然保留;若nuw_size > size,即扩大*ptr所指向的内存空间,如果原先的内存尾部有足够的扩大空间,则直接在原先的内存块尾部新增内存,如果原先的内存尾部空间不足,或原先的内存块无法改变大小,realloc将重新分配另一块nuw_size大小的内存,并把原先那块内存的内容复制到新的内存块上。因此,使用realloc后就应该改用realloc返回的新指针。

    展开全文
  • realloc,malloc,calloc的区别: 三个函数的申明分别是: void* realloc(void* ptr, unsigned newsize); void* malloc(unsigned size); void* calloc(size_t numElements, size_t sizeOfElement); 都在...

    realloc,malloc,calloc的区别:

    三个函数的申明分别是:
    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”字节的连续区域,返回该区域的首地址。 要自己memset初始化。
    calloc调用形式为(类型*)calloc(n,size):在内存的动态存储区中分配n块长度为“size”字节的连续区域,返回首地址。 并初始化为0。
    realloc调用形式为(类型*)realloc(*ptr,size):将ptr内存大小增大到size。


     new delete和malloc free的区别:

    相同点:都可用于申请动态内存和释放内存

    不同点:
    (1)操作对象有所不同。
    malloc与free是C++/C 语言的标准库函数,new/delete 是C++的运算符。对于非内部数据类的对象而言,光用maloc/free 无法满足动态对象的要求。对象在创建的同时要自动执行构造函数, 对象消亡之前要自动执行析构函数。由于malloc/free 是库函数而不是运算符,不在编译器控制权限之内,不能够把执行构造函数和析构函数的任务强加malloc/free。

    (2)用法上也有所不同。
    函数malloc 的原型如下:
    void * malloc(size_t size);
    用malloc 申请一块长度为length 的整数类型的内存,程序如下:
    int *p = (int *) malloc(sizeof(int) * length);
    我们应当把注意力集中在两个要素上:“类型转换”和“sizeof”。
    1、malloc 返回值的类型是void *,所以在调用malloc 时要显式地进行类型转换,将void * 转换成所需要的指针类型。
    2、 malloc 函数本身并不识别要申请的内存是什么类型,它只关心内存的总字节数。
    函数free 的原型如下:
    void free( void * memblock );
    为什么free 函数不象malloc 函数那样复杂呢?这是因为指针p 的类型以及它所指的内存的容量事先都是知道的,语句free(p)能正确地释放内存。如果p 是NULL 指针,那么free
    对p 无论操作多少次都不会出问题。如果p 不是NULL 指针,那么free 对p连续操作两次就会导致程序运行错误。


    new/delete 的使用要点:
    运算符new 使用起来要比函数malloc 简单得多,例如:
    int *p1 = (int *)malloc(sizeof(int) * length);
    int *p2 = new int[length];
    这是因为new 内置了sizeof、类型转换和类型安全检查功能。对于非内部数据类型的对象而言,new 在创建动态对象的同时完成了初始化工作。如果对象有多个构造函数,那么new 的语句也可以有多种形式。
    如果用new 创建对象数组,那么只能使用对象的无参数构造函数。例如
    Obj *objects = new Obj[100];       // 创建100 个动态对象
    不能写成
    Obj *objects = new Obj[100](1);        // 创建100 个动态对象的同时赋初值1
    在用delete 释放对象数组时,留意不要丢了符号‘[]’。例如
    delete []objects; // 正确的用法
    delete objects; // 错误的用法
    后者相当于delete objects[0],漏掉了另外99 个对象。

            1、new自动计算需要分配的空间,而malloc需要手工计算字节数
            2、new是类型安全的,而malloc不是,比如:
                     int* p = new float[2]; // 编译时指出错误
                     int* p = malloc(2*sizeof(float)); // 编译时无法指出错误
              new operator 由两步构成,分别是 operator new 和 construct
            3、operator new对应于malloc,但operator new可以重载,可以自定义内存分配策略,甚至不做内存分配,甚至分配到非内存设备上。而malloc无能为力
            4、new将调用constructor,而malloc不能;delete将调用destructor,而free不能。
            5、malloc/free要库文件支持,new/delete则不要。


    1、本质区别
    malloc/free是C/C++语言的标准库函数,new/delete是C++的运算符。
    对于用户自定义的对象而言,用maloc/free无法满足动态管理对象的要求。对象在创建的同时要自动执行构造函数,对象在消亡之前要自动执行析构函数。由于malloc/free是库函数而不是运算符,不在编译器控制权限之内,不能够把执行构造函数和析构函数的任务强加于malloc/free。因此C++需要一个能完成动态内存分配和初始化工作的运算符new,以及一个能完成清理与释放内存工作的运算符delete。

    [cpp] view plain copy
    1. class Obj  
    2. {  
    3. public:  
    4.     Obj( )   
    5.     { cout  <<  "Initialization"  <<  endl; }  
    6.     ~ Obj( )  
    7.     { cout  <<  "Destroy" <<  endl; }  
    8.     void Initialize( )  
    9.     { cout  <<  "Initialization"  <<  endl; }  
    10.     void  Destroy( )  
    11.     { cout  <<  "Destroy"  <<  endl; }  
    12. }obj;  
    13.   
    14. void  UseMallocFree( )  
    15. {  
    16.     Obj   * a  =  (Obj  *) malloc( sizeof ( obj ) );      //  allocate memory   
    17.     a -> Initialize();                                    //  initialization  
    18.     // …   
    19.     a -> Destroy();                                        // deconstruction   
    20.     free(a);                                               // release memory  
    21. }  
    22.   
    23. void  UseNewDelete( void )  
    24. {  
    25.     Obj   * a  =   new  Obj;                                             
    26.     // …   
    27.     delete a;   
    28. }  

    类Obj的函数Initialize实现了构造函数的功能,函数Destroy实现了析构函数的功能。函数UseMallocFree中,由于malloc/free不能执行构造函数与析构函数,必须调用成员函数Initialize和Destroy来完成“构造”与“析构”。所以我们不要用malloc/free来完成动态对象的内存管理,应该用new/delete。由于内部数据类型的“对象”没有构造与析构的过程,对它们而言malloc/free和new/delete是等价的。

    2、联系
    既然new/delete的功能完全覆盖了malloc/free,为什么C++还保留malloc/free呢?因为C++程序经常要调用C函数,而C程序只能用malloc/free管理动态内存。如果用free释放“new创建的动态对象”,那么该对象因无法执行析构函数而可能导致程序出错。如果用delete释放“malloc申请的动态内存”,理论上讲程序不会出错,但是该程序的可读性很差。所以new/delete、malloc/free必须配对使用

    展开全文
  • calloc、reallocmalloc

    2019-05-31 17:22:13
    malloc和free 前提概要 C函数库中的malloc和free分别用于执行动态内存分配释放 以上两个函数在头文件stdlib.h中声明 函数原型 void *malloc ( size_t size ); void free ( void *po...

    malloc和free

          前提概要

                  C函数库中的malloc和free分别用于执行动态内存分配和释放

                   以上两个函数在头文件stdlib.h中声明

         函数原型

                 void *malloc ( size_t size );

                  void free ( void *pointer );

     

         malloc函数

               作用

                     在内存的动态存储区中分配一个长度为size的连续空间

              传参

                  无符号整形数

              返回值

                  指向所分配连续存储域起始地址的指针

             注意

                 函数未能成功分配存储空间(如内存不足)就会返回一个NULL指针,在调用该函数时应该检测返回值是否为NULL,确保非空之后再使用非常重要

                 malloc所分配的内存是一块连续的空间

                 malloc实际分配的内存空间可能会比你请求的多一点,但是这个行为只是由编译器定义

                 malloc不知道用户所需内存存储的数据类型,故malloc返回一个void *的指针(可以转换为任意类型指针)

    free函数

           前提概要

                 内存空间有限,不能无限制分配内存,故程序要尽量节省资源,当分配的内存空间不用时,需释放

           作用

                 释放指针(传参值为指针)指向的内存空间

           传参

                 传参可以是 NULL,或者 malloc、relloc、calloc 返回值

                传参为NULL不会产生任何效果,但不会报错

    calloc和realloc与malloc的区别

         calloc和realloc的原型

                   void *calloc ( size_t num_elements, size_t element_size );

                   void *realloc (void *ptr, size_t new_size );

           calloc和malloc区别

                 calloc返回内存空间指针前,会将内存空间初始化为0,malloc不会初始化(有时需要用memset进行初始化)

                 传参方式不同,calloc的参数包括所需元素的数量和每个元素的大小,再根据两个值换算进行内存空间分配

          realloc函数

                作用

                     用于修改原先已分配内存块的大小,可使一块内存扩大或缩小

                传参说明

                      当传参*ptr为空,即*ptr = NULL,则同malloc

                      当传参*ptr非空

                            若nuw_size < size,即缩小*ptr所指内存空间,该内存块尾部部分被拿掉,剩余部分空间的内容依然保留

                           若nuw_size > size,即扩大*ptr所指内存空间,如果原先内存尾部有足够的扩大空间,则直接在原先的内存块尾部新增内存,如果原先的内存尾部空间不足,或原先的内存块无法改变大小,realloc将重新分配另一块nuw_size大小的内存,并把原先那块内存的内容复制到新的内存块上,因此,使用realloc后就应该改用realloc返回的新指针

              注意

                    realloc分配失败,ptr 指向的内存不会被释放,它的内容也不会改变,依然可以正常使用

    参考例程

       int *p1,*p2; 
       p1 = (int*)malloc(size * sizeof(int));
       p2=p1; 
       ……   
       free(p1);  /*或者free(p2)*/

         

    展开全文
  • void* realloc(void* ptr, unsigned newsize); void* malloc(unsigned size); void* calloc(size_t numElements, size_t sizeOfElement); 它们的返回值都是请求系统分配的地址,如果请求失败就返回NULL ...
  • realloc原型:extern void *realloc(void *mem_address, unsigned int newsize);用法:#include <stdlib.h> 有些编译器需要#include <alloc.h> 在C++环境中,使用#include<iostream> using ...
  • realloc malloc calloc函数

    2020-04-13 23:59:24
    calloc 在堆上分配内存,和malloc基本相同,但之后要对申请的内存空间清0,相当于malloc + memset,O(n) realloc 相当于重新分配内存,把之前的数据搬到新内存中去 一般在使用时均为malloc + memset,可读性好 ...
  • 关于malloc和realloc的用法使用区别

    万次阅读 多人点赞 2018-07-23 11:31:56
    在写第二个关于游戏的项目 ,贪吃蛇,这个估计很多人编过,刚开始编辑,所以遇到了一些比较easy的问题,但是对我来说还是比较有记得意义的,realloc和malloc的使用区别;  (1)realloc(void *ptr,size_t size);...
  • realloc、calloc和malloc

    2014-03-04 14:47:03
    三个函数的申明分别是: void* realloc(void* ptr, unsigned newsize); void* malloc(unsigned size); void* calloc(size_t numElements, size_t sizeOfElement); 都在stdlib.h函数库内 它们的返回值都是请求系统分配...
  • Look at the code:#include#includevoid main(){int ...p = malloc(6);p = realloc(p, 10);if (p == NULL){printf("error");exit(1);}}Take this example for the code, suppose the total memory is 10 bytes and 2...
  • malloc,calloc和realloc

    2017-10-13 13:29:56
    C语言在进行动态内存时常会用到的三个函数分别是malloc,calloc和reallocmalloc函数原型为:void *malloc(size_t size); malloc的作用用于在内存中开辟连续的size个字节,并返回该内存块的起始地址,如果开辟...
  • malloc和realloc

    2014-12-10 15:22:20
    #include "stdio.h" #include "stdlib.h" int main() { int a[4] = {1,2,3,4};... int *p = (int *)malloc(3*sizeof(int)); p[0] = 0; p[1] = 1; p[2] = 2; for (int i = 0;i;i++) { printf("%d ",p[i]
  • C语言之malloc和realloc

    2019-03-06 09:11:25
    C语言之malloc和realloc 前言: 利用malloc和realloc函数对内存进行动态分配,有利用提高内存的使用效率,并可以在程序开始时不用确定内存的大小。 一、malloc和free 他们都在头文件stdlib.h中声明,函数的原型如下 ...
  • 内存分配 学校项目,其中包括重新编码stdlib函数mallocrealloc和free
  • malloc calloc realloc和new

    2015-08-31 15:47:00
    1) malloc 函数: void *malloc(unsigned int size)  在内存的动态分配区域中分配一个长度为size的连续空间,如果分配成功,则返回所分配内存空间的首地址,否则返回NULL,申请的内存不会进行初始化。但是malloc...
  • malloc calloc realloc

    2015-09-08 17:15:04
    realloc()函数 原型:extern void *realloc(void *mem_address, unsigned int newsize); 语法:指针名=(数据类型*)realloc(要改变内存大小的指针名,新的大小)。 头文件:#include stdlib.h> 有些编译器需要#...
  • 1、malloc分配一块空间,但它不能初始化内存空间。返回值为void*,cC++允许强制转换 2、calloc分配空间并将该空间中的值初始化为0 3、realloc重新分配空间大小(缩小或放大),一般会在已有的空间后边开辟内存,...
  • malloc realloc

    2018-03-30 17:48:35
    还有另一个内存区域,称为栈(stack),其中的空间分配给函数的参数本地变量。在执行完该函数后,存储参数本地变量的内存空间就会释放。堆中的内存是由程序员控制的。在分配堆上的内存时,由程序员跟踪所分配的...
  • malloc():ElemType * head=(ElemType *)malloc(SIZE*sizeof(ElemType));...—————————-realloc(): //更改由malloc()分配的空间 head=(ElemType *)realloc(head,(SIZE+10)*sizeof(ElemType));将 h
  • 参考链接: ...http://www.runoob.com/cprogramming/c-function-realloc.html 动态内存的申请与释放必须配对,程序中malloc与free的使用次数一定要相同,否则肯定有错误...malloc和new的效果相似,但是如果想追加内...
  • 这四个函数都在#include<stdlib.h>里面声明。 1.malloc ...系统无法想向malloc提供更多的内存,malloc就返回一个NULL指针。 2.free 形式: void free(void *pointer); 说明:free的参数要...
  • 在C语言的学习中,如果遇到用户输入的数据大小不确定或者是想要通过函数返回一个可用的堆空间,这时就需要了解动态分配内存大小的函数malloc,而realloc则是对空间进行扩容 1.malloc and realloc 头文件: #include&...
  • int main() { int i = 0; int* pI = (int*)malloc(5 * sizeof(int)); short* pS = (short*)calloc(5, sizeof(short)); for(i=0; i<5; i++) { printf("pI[%d] = %d, pS[%d] = %d...
  • malloc realloc 的使用

    千次阅读 2016-11-13 23:21:01
    最近应美国运营商的需求写一个程序,需要从高通log中解析手机语音数据的注册信息,显示到组件上。   解析出的信息要写入一个字符串中。在给字符串分配内存空间时,遇到一些小问题。 1) malloc 函数  void *...
  • malloc calloc realloc

    2019-11-06 10:10:47
    /* realloc的机制:如果比原来分配的内存要大,有两种情况 1、如果原来空间的后面有足够大的空间,那么直接在后面继续开辟内存,返回原来 的地址 2、如果原来空间的后面没有足够大的空间,那么系统...calloc和malloc...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,310
精华内容 524
关键字:

realloc和malloc