搬砖:c语言中realloc()函数解析

c语言中realloc()函数解析

https://blog.csdn.net/hackerain/article/details/7954006

2012年09月07日 10:51:49 hackerain 阅读数:53134 标签: numbers 语言 c ubuntu null input 更多

个人分类: 操作系统/Linux

真是有点惭愧,这些内容本应该很早就掌握的,以前只是糊里糊涂的用,不知道在内存中具体是怎么回事,现在才弄清楚。

 

realloc(void *__ptr, size_t __size):更改已经配置的内存空间,即更改由malloc()函数分配的内存空间的大小。


如果将分配的内存减少,realloc仅仅是改变索引的信息。


如果是将分配的内存扩大,则有以下情况:
1)如果当前内存段后面有需要的内存空间,则直接扩展这段内存空间,realloc()将返回原指针。
2)如果当前内存段后面的空闲字节不够,那么就使用堆中的第一个能够满足这一要求的内存块,将目前的数据复制到新的位置,并将原来的数据块释放掉,返回新的内存块位置。
3)如果申请失败,将返回NULL,此时,原来的指针仍然有效。

注意:如果调用成功,不管当前内存段后面的空闲空间是否满足要求,都会释放掉原来的指针,重新返回一个指针,虽然返回的指针有可能和原来的指针一样,即不能再次释放掉原来的指针。

看一下示例代码

 
  1. #include

  2. #include

  3.  
  4. int main(int argc, char* argv[], char* envp[])

  5. {

  6. int input;

  7. int n;

  8. int *numbers1;

  9. int *numbers2;

  10. numbers1=NULL;

  11.  
  12. if((numbers2=(int *)malloc(5*sizeof(int)))==NULL)//为numbers2在堆中分配内存空间

  13. {

  14. printf("malloc memory unsuccessful");

  15. exit(1);

  16. }

  17.  
  18. printf("numbers2 addr: %8X\n",(int)numbers2);

  19.  
  20. for(n=0;n<5;n++) //初始化

  21. {

  22. *(numbers2+n)=n;

  23. //printf("numbers2's data: %d\n",*(numbers2+n));

  24. }

  25.  
  26. printf("Enter new size: ");

  27. scanf("%d",&input);

  28.  
  29. //重新分配内存空间,如果分配成功的话,就释放numbers2指针,

  30. //但是并没有将numbers2指针赋为NULL,也就是说释放掉的是系统分配的堆空间,

  31. //和该指针没有直接的关系,现在仍然可以用numbers2来访问这部分堆空间,但是

  32. //现在的堆空间已经不属于该进程的了。

  33. numbers1=(int *)realloc(numbers2,(input+5)*sizeof(int));

  34.  
  35. if(numbers1==NULL)

  36. {

  37. printf("Error (re)allocating memory");

  38. exit(1);

  39. }

  40.  
  41. printf("numbers1 addr: %8X\n",(int)numbers1);

  42.  
  43. /*for(n=0;n<5;n++) //输出从numbers2拷贝来的数据

  44. {

  45. printf("the numbers1's data copy from numbers2: %d\n",*(numbers1+n));

  46. }*/

  47.  
  48. for(n=0;n

  49. {

  50. *(numbers1+5+n)=n+5;

  51. //printf("numbers1' new data: %d\n",*(numbers1+5+n));

  52. }

  53.  
  54. printf("\n");

  55.  
  56. free(numbers1);//释放numbers1,此处不需要释放numbers1,因为在realloc()时已经释放

  57. numbers1=NULL;

  58. //free(numbers2);//不能再次释放

  59. return 0;

  60. }

如果当前内存段后有足够的空间,realloc()返回原来的指针:

yugsuo@ubuntu:~/linux/memange$ gcc -g -o realloc realloc_example.c 
yugsuo@ubuntu:~/linux/memange$ ./realloc 
numbers2 addr:  8AFC008
Enter new size: 10
numbers1 addr:  8AFC008

如果当前内存段后没有足够的空间,realloc()返回一个新的内存段的指针:

yugsuo@ubuntu:~/linux/memange$ ./realloc 
numbers2 addr:  9505008
Enter new size: 1000000
numbers1 addr: B716F008

 

 

 

https://blog.csdn.net/u014170207/article/details/53126340

对于这个说烂的问题 ,做一点感悟笔记。三者都是分配内存,都是stdlib.h库里的函数,但是也存在一些细微的差异。


首先,对于malloc函数。其原型void *malloc(unsigned int num_bytes)

num_byte为要申请的空间大小,需要我们手动的去计算,如int *p = (int *)malloc(20*sizeof(int)),如果编译器默认int为4字节存储的话,那么计算结果是80Byte,一次申请一

个80Byte的连续空间,并将空间基地址强制转换为int类型,赋值给指针p,此时申请的内存值是不确定的。


而对于calloc函数,其原型void *calloc(size_t n, size_t size);

从直观的看,其比malloc函数多一个参数,并不需要人为的计算空间的大小,比如如果他要申请20个int类型空间,会int *p = (int *)calloc(20, sizeof(int)),这样就省去了人为空

间计算的麻烦。但这并不是他们之间最重要的区别,malloc申请后空间的值是随机的,并没有进行初始化,而calloc却在申请后,对空间逐一进行初始化,并设置值为0;

如下

        int *p = (int *)malloc(20*sizeof(int));
        int *pp = (int *)calloc(20, sizeof(int));
        int i;
        
        printf("malloc申请的空间值:\n\n");
        for ( i=0 ; i < 20; i++)
        {
            printf("%d ", *p++);
        }
        printf("\n\n");
        printf("calloc申请的空间的值:\n\n");
        for ( i=0 ; i < 20; i++)
        {
            printf("%d ", *pp++);
        }
        printf("\n");

 

结果为

很多人会疑问:既然calloc不需要计算空间并且可以直接初始化内存避免错误,那为什么不直接使用calloc函数,那要malloc要什么用呢?

实际上,任何事物都有两面性,有好的一面,必然存在不好的地方。这就是效率。calloc函数由于给每一个空间都要初始化值,那必然效率较malloc要低,并且现实世界,很多情况的空间申请是不需要初始值的,这也就是为什么许多初学者更多的接触malloc函数的原因。

说完了malloc和calloc,接下来谈realloc函数。

realloc函数和上面两个有本质的区别,

其原型void realloc(void *ptr, size_t new_Size) 用于对动态内存进行扩容(及已申请的动态空间不够使用,需要进行空间扩容操作)

ptr为指向原来空间基址的指针, new_size为接下来需要扩充容量的大小


    int main(void)
    {
        const int size = 2000;
        int *p = (int *)malloc(20*sizeof(int));
        int *pp = (int *)realloc(p, size*sizeof(int));
        
        printf("原来的p_Address:%x   扩容后的pp_Address:%x \n\n", p, pp);
        
        return 0;
    }

 

结果为:

可从图看出,扩容后地址和原先地址是不一样的,但是这仅仅取决于扩容的内存大小。

实际上:

        如果size较小,原来申请的动态内存后面还有空余内存,系统将直接在原内存空间后面扩容,并返回原动态空间基地址;

        如果size较大,原来申请的空间后面没有足够大的空间扩容,系统将重新申请一块(20+size)*sizeof(int)的内存,并把原来空间的内容拷贝过去,原来空间free;

        如果size非常大,系统内存申请失败,返回NULL,原来的内存不会释放。

注意:如果扩容后的内存空间较原空间小,将会出现数据丢失,如果直接realloc(p, 0);相当于free(p)

完结。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

 
---------------------  
作者:EtcFly  
来源:CSDN  
原文:https://blog.csdn.net/u014170207/article/details/53126340  
版权声明:本文为博主原创文章,转载请附上博文链接!

 

你可能感兴趣的:(c/c++)