精华内容
下载资源
问答
  • realloc函数的用法

    2015-06-05 14:02:00
    realloc(void *__ptr, size_t __size):更改已经配置内存空间,即更改由malloc()函数分配内存空间大小。 如果将分配内存减少,realloc仅仅是改变索引信息。 如果是将分配内存扩大,则有以下情况: 1...


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

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


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

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

    看一下示例代码

    1. #include <stdio.h>  
    2. #include <stdlib.h>  
    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<input;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()返回原来的指针:

    [plain] view plaincopy
    1. yugsuo@ubuntu:~/linux/memange$ gcc -g -o realloc realloc_example.c   
    2. yugsuo@ubuntu:~/linux/memange$ ./realloc   
    3. numbers2 addr:  8AFC008  
    4. Enter new size: 10  
    5. numbers1 addr:  8AFC008  

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

    [plain] view plaincopy
    1. yugsuo@ubuntu:~/linux/memange$ ./realloc   
    2. numbers2 addr:  9505008  
    3. Enter new size: 1000000  
    4. numbers1 addr: B716F008  

    转载于:https://www.cnblogs.com/fangyan5218/p/10618274.html

    展开全文
  • C\C++ 中 malloc、calloc、realloc 函数的用法 转自:https://www.jianshu.com/p/d6f209b8796d 前言 C\C++提供了底层的内存操作,为程序提供了强大的能力。在使用 malloc() calloc() realloc() 进行动态内存...

    C\C++ 中 malloc、calloc、realloc 函数的用法

     

    转自:https://www.jianshu.com/p/d6f209b8796d

     

    前言

    C\C++提供了底层的内存操作,为程序提供了强大的能力。在使用 malloc() calloc() realloc() 进行动态内存分配时,内存区域中的这个空间称为堆(heap),另一个内存区域,称为栈(stack),其中的空间分配给函数的参数和本地变量,执行完该函数后,存储参数和本地变量的内存空间就会自

     

    动释放。而堆中的内存是由人控制的,在分配堆上的内存时,需要人自己来判断什么时候需要分配,什么时候需要释放。

    malloc

    1. 函数原型
      (TYPE *) malloc(SIZE)
    2. 函数功能
      malloc() 在内存的动态存储区中分配一块长度为 SIZE 字节的连续区域。参数 SIZE 为需要的内存空间的长度,返回该区域的地址。malloc() 函数不能为所分配的空间初始化值,需要使用 memset(),不然可能会出现内存中遗留的数据。在程序结束前,需要使用 free() 进行内存释放。
    3. 使用
    int *p = NULL;
    p = (int *) malloc(sizeof(int)); // 申请
    memset(p, 20, sizeof(int) / 4); // 赋初值(不可取)
    printf("%d\n", *p); // 20
    free(p); // 释放
    

    主要注意的是,memset() 是按照字节来进行赋值,而 char 类型的空间恰好是1字节,所以 memset() 最好用于 char 类型的赋值。当然,也可以用 sizeof(int) / 4 来给 int 类型赋值,只不过只能赋 0x00 - oxff 的值。不然的话就是按位赋值四次。

    char *p = NULL;
    p = (char *) malloc(sizeof(char));
    memset(p, 'g', sizeof(char));
    printf("%c\n", *p); // g
    free(p);
    p = NULL;
    

    如上,char 类型可以完美的赋值。

    calloc

    1. 函数原型
      (TYPE * )calloc(int n, SIZE);
    2. 函数功能
      calloc() 函数功能和 malloc 类似,都是从堆内存中分配内存,不同的是,calloc() 会自动进行初始化,每一位都初始化为零。n 表示元素的个数,SIZE 为单位元素的长度,从定义上看,calloc() 适合为数组申请动态内存。与 malloc() 最后也需要使用 free() 进行内存释放。
    3. 使用
    #define SIZE 10
    int *p;
    p = (int *) calloc(SIZE, sizeof(int));
    for (int i = 0; i < SIZE; ++i) {
        p[i] = i;
    }
    for (int j = 0; j < SIZE; ++j) {
        printf("%d\n", p[j]); // 0, 1, 2, 3, 4, 5 ...
    }
    free(p);
    p = NULL;
    

    realloc

    1. 函数原型
      (TYPE * )realloc(TYPE *ptr, NEW_SIZE);
    2. 函数功能
      realloc() 是给一个已经分配了地址的指针重新分配动态内存空间,*ptr 为原有的空间地址,NEW_SIZE 是重新申请的空间,若新的空间小于之前的空间,则不会进行改变,若新的空间大于原来的空间,则会从堆内存中为 *ptr 分配一个大小为 NEW_SIZE 的空间吗,同时将原来空间的内容依次复制进新的地址空间,*ptr 之前的空间被释放,realloc() 所分配的空间也是未初始化的。
    3. 使用
    #define SIZE 10
    int *p;
    p = (int *) calloc(SIZE, sizeof(int));
    for (int i = 0; i < SIZE; ++i) {
        p[i] = i;
    }
    p = (int *) realloc(p, SIZE * 2);
    for (int j = 10; j < SIZE * 2; ++j) {
        p[j] = j;
    }
    for (int k = 0; k < SIZE * 2; ++k) {
        printf("%d\n", p[k]); // 1, 2, 3, ... , 19
    }
    free(p);
    p 
    展开全文
  • 用法:#include 有些编译器须要#include 功能:改变mem_address所指内存区域大小为newsize长度。说明:若是从新分配成功则返回指向被分配内存指针,不然返回空指针NULL。当内存再也不使用时,应使用free()函数将...

    realloc

    原型:extern void *realloc(void *mem_address, unsigned int newsize);

    用法:#include 有些编译器须要#include

    功能:改变mem_address所指内存区域的大小为newsize长度。

    说明:若是从新分配成功则返回指向被分配内存的指针,不然返回空指针NULL。

    当内存再也不使用时,应使用free()函数将内存块释放。

    注意:这里原始内存中的数据仍是保持不变的。css

    下面 经过 代码来认识一下:html

    #include

    #include

    main()

    {

    char *p;

    p=(char *)malloc(100);

    if(p)

    printf("Memory Allocated at: %p\n",p);

    else

    printf("Not Enough Memory!/n");

    char *lcf=(char *)realloc(p,256);

    if(lcf)

    printf("Memory Reallocated at: %p\n",lcf);

    else

    printf("Not Enough Memory!/n");

    free(lcf);

    return 0;

    }

    详细说明及注意要点:一、若是有足够空间用于扩大mem_address指向的内存块,则分配额外内存,并返回mem_address这里说的是“扩大”,咱们知道,realloc是从堆上分配内存的,当扩大一块内存空间时, realloc()试图直接从堆上现存的数据后面的那些字节中得到附加的字节,若是可以知足,天然天下太平。也就是说,若是原先的内存大小后面还有足够的空闲空间用来分配,加上原来的空间大小= newsize。那么就ok。获得的是一块连续的内存。二、若是原先的内存大小后面没有足够的空闲空间用来分配,那么从堆中另外找一块newsize大小的内存。并把原来大小内存空间中的内容复制到newsize中。返回新的mem_address指针。(数据被移动了)。老块被放回堆上。例如:#include char *p,*q;p = (char * ) malloc (10);q=p;p = (char * ) realloc (p,20);…………………………这段程序也许在编译器中没有办法经过,由于编译器可能会为咱们消除一些隐患!在这里咱们只是增长了一个记录原来内存地址的指针q,而后记录了原来的内存地址p,若是不幸的话,数据发生了移动,那么所记录的原来的内存地址q所指向的内存空间实际上已经放回到堆上了!这样一来,咱们应该终于意识到问题的所在和可怕了吧!三、返回状况返回的是一个void类型的指针,调用成功。(这就再你须要的时候进行强制类型转换)返回NULL,当须要扩展的大小(第二个参数)为0而且第一个参数不为NULL,此时原内存变成了“freed(游离)”的了。返回NULL,当没有足够的空间可供扩展的时候,此时,原内存空间的大小维持不变。四、特殊状况若是mem_address为null,则realloc()和malloc()相似。分配一个newsize的内存块,返回一个指向该内存块的指针。若是newsize大小为0,那么释放mem_address指向的内存,并返回null。若是没有足够可用的内存用来完成从新分配(扩大原来的内存块或者分配新的内存块),则返回null.而原来的内存块保持不变。编程

    引用:安全

    ==============================================================less

    void* malloc(unsigned size); void* calloc(size_t nelem, size_t elsize); 和void* realloc(void* ptr, unsigned newsize);都在stdlib.h函数库内,是C语言的标准内存分配函数。

    1. 函数malloc()和calloc()均可以用来动态分配内存空间。malloc()函数有一个参数,即要分配的内存空间的大小,malloc 在分配内存时会保留必定的空间用来记录分配状况,分配的次数越多,这些记录占用的空间就越多。另外,根据 malloc 实现策略的不一样,malloc 每次在分配的时候,可能分配的空间比实际要求的多些,屡次分配会致使更多的这种浪费。固然,这些都和 malloc 的实现有关;calloc()函数有两个参数,分别为元素的数目和每一个元素的大小,这两个参数的乘积就是要分配的内存空间的大小。若是调用成功,它们都将返回所分配内存空间的首地址。

    2. 函数malloc()和函数calloc()的主要区别是前者不能初始化所分配的内存空间,然后者能。 char* a = (char*)calloc(1, sizeof(int));

    3. realloc能够对给定的指针所指的空间进行扩大或者缩小,不管是扩张或是缩小,原有内存的中内容将保持不变。固然,对于缩小,则被缩小的那一部分的内容会丢失。

    4. realloc 并不保证调整后的内存空间和原来的内存空间保持同一内存地址。相反,realloc 返回的指针极可能指向一个新的地址。因此在代码中,我们必须将realloc返回的值,从新赋值给 p :

    p = (int *) realloc (p, sizeof(int) *15);ide

    ==================================================================函数

    关于realloc函数说明的补充:

    函数定义:

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

    上面的分析基本没有问题,但有两点要注意:

    一、返回值可能与ptr的值不一样,若是是不一样的话,那么realloc函数完成后,ptr指向的旧内存已被free掉了。

    二、若是返回NULL值,则分配不成功,而原来的ptr指向的内存尚未被free掉,要求程序显式free.

    故p = (int *) realloc (p, sizeof(int) *15);语句有这么一个问题,

    调用前p指向一个已分配成功的内存,而调用realloc时却失败(即返回NULL),此时,p原来指向的内存尚未free掉,而如今又找不到地址,这样就出现memory leak了。

    关于这一点的确要注意,最好以下:

    int *q

    q = (int *) realloc (p, sizeof(int) *15);

    if(!q) p =q;

    最后 仍是引用 大神博客文章: http://blog.chinaunix.net/uid-23629988-id-371240.html

    在良好的代码风格中,其中有一项要求就是,一个函数只作一件事情。若是该函数实现了多个功能,那基本上能够说这不是一个设计良好的函数。

    今天看C库中的函数realloc。其原型是

    void *realloc(void *ptr, size_t size);函数说明以下:

    realloc() changes the size of the memory block pointed to by ptr to size bytes. The contents will be unchanged to the minimum of the old and new sizes; newly allocated memory will be uninitialized. If ptr is NULL, the call is equivalent to malloc(size); if sizeis equal to zero, the call is equivalent to free(ptr). Unless ptr is NULL, it must have been returned by an earlier call to malloc(), calloc() or realloc(). If the area pointed to was moved, a free(ptr) is done.

    总结一下,有如下几种行为:

    1. 与名字相符,真正的realloc,参数ptr和size均不为NULL,从新调整内存大小,并将新的内存指针返回,并保证最小的size的内容不变;

    2. 参数ptr为NULL,但size不为0,那么行为就等于malloc(size);

    3. 参数size为0,则realloc的行为为free(ptr);这时原有的指针已经被free掉,不能继续使用。而此时realloc的返回值为NULL。这意味着不检查realloc的返回值,直接使用,会致使crash。

    看,一个简单C库函数,却赋予了三种行为,因此这个realloc并非设计良好的库函数。估计也是为了兼容性,才容忍这个函数一直在C库中。虽然在编码中,realloc会提供必定的方便,可是也很容易引起bug。

    下面就举两个例子,来讲明一下。

    1. realloc第一种行为引起的bug

    void *ptr = realloc(ptr, new_size);

    if (!ptr) {

    错误处理

    }

    这里就引出了一个内存泄露的问题,当realloc分配失败的时候,会返回NULL。可是参数中的ptr的内存是没有被释放的。若是直接将realloc的返回值赋给ptr。那么当申请内存失败时,就会形成ptr原来指向的内存丢失,形成泄露。

    正确的处理应该是这样

    void *new_ptr = realloc(ptr, new_size);

    if (!new_ptr) {

    错误处理。

    }

    ptr = new_ptr

    2. 第三种行为引起的bug

    这种bug由一种很差的编程习惯引起的。即认为申请内存始终能够成功,所以并不检查malloc的返回值。这在通常状况下,不会引起问题。可是对于realloc来讲,当new_size为0时,realloc返回NULL。而在后面的代码上,继续使用new_ptr,好比会致使程序crash。

    void *new_ptr = realloc(old_ptr, new_size);

    //其它代码

    ...... ......

    从上面能够看出,在面对这个设计并不是良好的API时,咱们须要当心当心再当心。上面只是举了两个例子,其实还有一些其它的小问题

    最后 再次 上代码已经是说明:ui

    #include

    #include

    main()

    {

    char *p;

    p=(char *)malloc(100);

    if(p)

    printf("Memory Allocated at: %p\n",p);

    else

    printf("Not Enough Memory!/n");

    char *new_p=(char *)realloc(p,256);

    if(new_p)

    {

    printf("Memory Reallocated at: %p\n",new_p);

    }

    else

    {

    printf("Not Enough Memory!/n");

    free(p);

    p = NULL;

    return -1;

    }

    p = new_p;

    free(p);

    return 0;

    }

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

           注意:这里原始内存中的数据还是保持不变的。 

    下面 通过 代码来认识一下:

    1. #include <stdlib.h>  
    2. #include<stdio.h>  
    3.   
    4. main()  
    5. {  
    6.         char *p;  
    7.         p=(char *)malloc(100);  
    8.         if(p)  
    9.                 printf("Memory Allocated at: %p\n",p);  
    10.         else  
    11.                 printf("Not Enough Memory!/n");  
    12.         char *lcf=(char *)realloc(p,256);  
    13.         if(lcf)  
    14.                 printf("Memory Reallocated at: %p\n",lcf);  
    15.         else  
    16.                 printf("Not Enough Memory!/n");  
    17.         free(lcf);  
    18.         return 0;  
    19. }  

    详细说明及注意要点: 
    1、如果有足够空间用于扩大mem_address指向的内存块,则分配额外内存,并返回mem_address 
    这里说的是“扩大”,我们知道,realloc是从堆上分配内存的,当扩大一块内存空间时, realloc()试图直接从堆上现存的数据后面的那些字节中获得附加的字节,如果能够满足,自然天下太平。也就是说,如果原先的内存大小后面还有足够的空闲空间用来分配,加上原来的空间大小= newsize。那么就ok。得到的是一块连续的内存。 
    2、如果原先的内存大小后面没有足够的空闲空间用来分配,那么从堆中另外找一块newsize大小的内存。 
    并把原来大小内存空间中的内容复制到newsize中。返回新的mem_address指针。(数据被移动了)。 
    老块被放回堆上。 
    例如: 
    #include <malloc.h> 
    char *p,*q; 
    p = (char * ) malloc (10); 
    q=p; 
    p = (char * ) realloc (p,20); 
    ………………………… 
    这段程序也许在编译器中没有办法通过,因为编译器可能会为我们消除一些隐患!在这里我们只是增加了一个记录原来内存地址的指针q,然后记录了原来的内存地址p,如果不幸的话,数据发生了移动,那么所记录的原来的内存地址q所指向的内存空间实际上已经放回到堆上了!这样一来,我们应该终于意识到问题的所在和可怕了吧! 
    3、返回情况 
    返回的是一个void类型的指针,调用成功。(这就再你需要的时候进行强制类型转换) 
    返回NULL,当需要扩展的大小(第二个参数)为0并且第一个参数不为NULL,此时原内存变成了“freed(游离)”的了。 
    返回NULL,当没有足够的空间可供扩展的时候,此时,原内存空间的大小维持不变。 
    4、特殊情况 
    如果mem_address为null,则realloc()和malloc()类似。分配一个newsize的内存块,返回一个指向该内存块的指针。
    如果newsize大小为0,那么释放mem_address指向的内存,并返回null。 
    如果没有足够可用的内存用来完成重新分配(扩大原来的内存块或者分配新的内存块),则返回null.而原来的内存块保持不变。


    引用:

    ==============================================================

     

    void* malloc(unsigned size); void* calloc(size_t nelem, size_t elsize); 和void* realloc(void* ptr, unsigned newsize);都在stdlib.h函数库内,是C语言的标准内存分配函数。
    1. 函数malloc()和calloc()都可以用来动态分配内存空间。malloc()函数有一个参数,即要分配的内存空间的大小,
    malloc 在分配内存时会保留一定的空间用来记录分配情况,分配的次数越多,这些记录占用的空间就越多。另外,根据 malloc 实现策略的不同,malloc 每次在分配的时候,可能分配的空间比实际要求的多些,多次分配会导致更多的这种浪费。当然,这些都和 malloc 的实现有关;calloc()函数有两个参数,分别为元素的数目和每个元素的大小,这两个参数的乘积就是要分配的内存空间的大小。如果调用成功,它们都将返回所分配内存空间的首地址。
    2. 函数malloc()和函数calloc()的主要区别是前者不能初始化所分配的内存
    空间,而后者能。 char* a = (char*)calloc(1, sizeof(int));
    3. realloc可以对给定的指针所指的空间进行扩大或者缩小,无论是扩张或是缩小,原有内存的中内容将保持不变。当然,对于缩小,则被缩小的那一
    部分的内容会丢失。
    4. realloc 并不保证调整后的内存空间和原来的内存空间保持同一内存地址。相反,realloc 返回的指针很可能指向一个新的地址。所以在代码中,我
    们必须将realloc返回的值,重新赋值给 p :
    p = (int *) realloc (p, sizeof(int) *15);


    ==================================================================

    关于realloc函数说明的补充:
    函数定义:
    void *realloc(void *ptr, size_t size);
    上面的分析基本没有问题,但有两点要注意:
    1、返回值可能与ptr的值不同,如果是不同的话,那么realloc函数完成后,ptr指向的旧内存已被free掉了。
    2、如果返回NULL值,则分配不成功,而原来的ptr指向的内存还没有被free掉,要求程序显式free.

    故p = (int *) realloc (p, sizeof(int) *15);语句有这么一个问题,
    调用前p指向一个已分配成功的内存,而调用realloc时却失败(即返回NULL),此时,p原来指向的内存还没有free掉,而现在又找不到地址,这样就出现memory leak了。

    关于这一点的确要注意,最好如下:
    1. int *q  
    2. q = (int *) realloc (p, sizeof(int) *15);  
    3. if(!q) p =q;  


    最后 还是引用 大神博客文章: http://blog.chinaunix.net/uid-23629988-id-371240.html

    在良好的代码风格中,其中有一项要求就是,一个函数只做一件事情。如果该函数实现了多个功能,那基本上可以说这不是一个设计良好的函数。

    今天看C库中的函数realloc。其原型是void *realloc(void *ptr, size_t size);函数说明如下:
    realloc() changes the size of the memory block pointed to by ptr to size bytes. The contents will be unchanged to the minimum of the old and new sizes; newly allocated memory will be uninitialized. If ptr is NULL, the call is equivalent to malloc(size); if sizeis equal to zero, the call is equivalent to free(ptr). Unless ptr is NULL, it must have been returned by an earlier call to malloc(), calloc() or realloc(). If the area pointed to was moved, a free(ptr) is done.

    总结一下,有以下几种行为:
    1. 与名字相符,真正的realloc,参数ptr和size均不为NULL,重新调整内存大小,并将新的内存指针返回,并保证最小的size的内容不变;
    2. 参数ptr为NULL,但size不为0,那么行为就等于malloc(size);
    3. 参数size为0,则realloc的行为为free(ptr);这时原有的指针已经被free掉,不能继续使用。而此时realloc的返回值为NULL。这意味着不检查realloc的返回值,直接使用,会导致crash。

    看,一个简单C库函数,却赋予了三种行为,所以这个realloc并不是设计良好的库函数。估计也是为了兼容性,才容忍这个函数一直在C库中。虽然在编码中,realloc会提供一定的方便,但是也很容易引发bug。

    下面就举两个例子,来说明一下。
    1. realloc第一种行为引发的bug
    1. void *ptr = realloc(ptr, new_size);
    2. if (!ptr) {
    3.     错误处理
    4. }
    这里就引出了一个内存泄露的问题,当realloc分配失败的时候,会返回NULL。但是参数中的ptr的内存是没有被释放的。如果直接将realloc的返回值赋给ptr。那么当申请内存失败时,就会造成ptr原来指向的内存丢失,造成泄露。

    正确的处理应该是这样
    1. void *new_ptr = realloc(ptr, new_size);
    2. if (!new_ptr) {
    3.     错误处理。
    4. }
    5. ptr = new_ptr

    2. 第三种行为引发的bug
    这种bug由一种不好的编程习惯引发的。即认为申请内存始终可以成功,因此并不检查malloc的返回值。这在一般情况下,不会引发问题。但是对于realloc来说,当new_size为0时,realloc返回NULL。而在后面的代码上,继续使用new_ptr,比如会导致程序crash。
    1. void *new_ptr = realloc(old_ptr, new_size);
     //其它代码
     ...... ......

    从上面可以看出,在面对这个设计并非良好的API时,我们需要小心小心再小心。上面只是举了两个例子,其实还有一些其它的小问题



    最后 再次 上代码已是说明:

    1. #include <stdlib.h>  
    2. #include<stdio.h>  
    3.   
    4. main()  
    5. {  
    6.         char *p;  
    7.         p=(char *)malloc(100);  
    8.         if(p)  
    9.                 printf("Memory Allocated at: %p\n",p);  
    10.         else  
    11.                 printf("Not Enough Memory!/n");  
    12.         char *new_p=(char *)realloc(p,256);  
    13.         if(new_p)  
    14.         {  
    15.                 printf("Memory Reallocated at: %p\n",new_p);  
    16.         }  
    17.         else  
    18.         {  
    19.                 printf("Not Enough Memory!/n");  
    20.                 free(p);  
    21.                 p = NULL;  
    22.                 return -1;  
    23.         }  
    24.         p = new_p;  
    25.   
    26.         free(p);  
    27.         return 0;  
    28. }  
    展开全文
  • C++内存分配 https://blog.csdn.net/zhangxiao93/article/details/43966425 转载于:https://www.cnblogs.com/lixuwu/p/9942034.html
  • realloc 用过很多次了。无非就是将已经存在一块内存扩大。char* p = malloc(1024);char* q = realloc(p,2048);现在问题是我们应该如何处理指针 p。 刚开始按照我最直观理解,如果就是直接将 p = NULL;。 到...
  • realloc函数用法

    2017-07-14 20:45:20
    函数原型:void *realloc(void *ptr, size_t size);功能: 重新分配大小为size一块内存,返回内存地址ptr。函数源码流程图:使用方法:/* realloc example: rememb-o-matic */ #include <stdio.h> /* printf, ...
  • malloc/calloc/realloc函数的区别及用法1.malloc函数2.calloc函数3.realloc函数 malloc/calloc/realloc函数都是分配内存,但是也存在一定的差异。 1.malloc函数 malloc函数文档 函数原型:void* malloc (size_t size...
  • calloc、malloc、realloc函数的区别及用法

    万次阅读 多人点赞 2018-08-08 10:12:04
    calloc、malloc、realloc函数的区别及用法! 三者都是分配内存,都是stdlib.h库里的函数,但是也存在一些差异。 (1)malloc函数。其原型void *malloc(unsigned int num_bytes); num_byte为要申请的空间大小,...
  • 三者都是分配内存,都是stdlib.h库里的函数,但是也存在一些差异。 (1)malloc函数。其原型void *malloc(unsigned int num_bytes); num_byte为要申请空间大小,需要我们手动去计算,如int *p = (int *)malloc...
  • C++ 函数 realloc 的用法

    2018-04-28 19:17:13
    void * realloc(void * mem_address, unsigned int newsize) 功能 先判断当前指针是否有足够连续空间: 如果有,扩大mem_address指向地址,返回mem_address 如果没有,先按newsize指定大小分配空间,将原...
  • realloc函_realloc函数

    2020-12-24 12:23:51
    用法:#include 功能:改变ptr所指内存区域大小为newsize长度。说明:如果重新分配成功则返回指向被分配内存指针,否则返回空指针NULL。当内存不再使用时,应使用free()函数将内存块释放。#include #include int...
  • calloc、malloc、realloc函数的区别及用法! 三者都是分配内存,都是stdlib.h库里的函数,但是也存在一些差异。 (1)malloc函数。其原型void *malloc(unsigned int num_bytes); num_byte为要申请的空间大小,...
  • realloc函数

    2014-09-29 00:16:05
    原型:extern void *realloc(void *ptr, size_t newsize); 用法:#include 功能:改变ptr所指内存区域大小为newsize长度。 说明:如果重新分配成功则返回指向被分配内存指针,否则返回空指针NULL。 当内存...
  • realloc函数的使用

    2010-03-03 16:19:45
    原型:extern void *realloc(void *mem_address, unsigned int newsize); 用法:#include 有些编译器需要#include 功能:改变mem_address所指内存区域大小为newsize长度。 说明:如果重新分配成功则返回...
  • 原型:externvoid *realloc(void *mem_address, unsigned int newsize);用法:#include 功能:改变mem_address所指内存区域的大小为newsize长度。说明:如果重新分配成功则...下面再看MSDN中对realloc()函数的描述...
  • realloc函数的使用及注意事项

    千次阅读 2014-04-25 11:12:55
    原型:extern void *realloc(void *mem_address, unsigned int newsize); 用法:#include 功能:改变mem_address所指内存区域大小为newsize长度。 说明:如果重新分配成功则返回指向被分配内存指针,...
  • realloc函数原型及使用

    2015-03-12 17:02:55
    realloc函数原型及使用  原型:extern void *realloc(void *mem_address, unsigned int newsize);  用法:#include 有些编译器需要#include  功能:改变mem_address所指内存区域大小为newsize长度...
  • malloc,calloc,realloc,free函数用法总结 头文件都是;#include<stdlib.h> 动态内存: 由于: 1.静态内存创建内存大小不太灵活,不能一次开辟连续空间大小(除过数组),无法在在运行时调整空间大小。 2....

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 133
精华内容 53
关键字:

realloc函数的用法