C语言中内存分配

柔光的暖阳◎ 2022-09-25 07:28 202阅读 0赞

[http://blog.csdn.net/youoran/article/details/10990815][http_blog.csdn.net_youoran_article_details_10990815]  
在任何程序设计环境及语言中，内存管理都十分重要。在目前的计算机系统或嵌入式系统中，内存资源仍然是有限的。因此在程序设计中，有效地管理内存资源是程序员首先考虑的问题。

第1节主要介绍内存管理基本概念，重点介绍C程序中内存的分配，以及C语言编译后的可执行程序的存储结构和运行结构，同时还介绍了堆空间和栈空间的用途及区别。
    
    第2节主要介绍C语言中内存分配及释放函数、函数的功能，以及如何调用这些函数申请/释放内存空间及其注意事项。
    
    3.1 内存管理基本概念
    
    3.1.1　C程序内存分配
    
    1．C程序结构
    
    下面列出C语言可执行程序的基本情况（Linux 2.6环境/GCC4.0）。
    
    [root@localhost Ctest]# ls test -l     //test为一个可执行程序
    -rwxr-xr-x  1 root root 4868 Mar 26 08:10 test
    [root@localhost Ctest]# file test //此文件基本情况
    test: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), 
    for GNU/Linux 2.2.5, dynamically linked (uses shared libs), not stripped
    [root@localhost Ctest]# size test  //此二进制可执行文件结构情况
    //代码区静态数据/全局初始化数据区　未初始化数据区　十进制总和　十六进制总和 文件名
    text   data         bss    dec    hex filename
    906    284          4    1194    4aa test
    可以看出，此可执行程序在存储时（没有调入到内存）分为代码区（text）、数据区（data）和未初始化数据区（bss）3个部分。
    
    （1）代码区（text segment）。存放CPU执行的机器指令（machine instructions）。通常，代码区是可共享的（即另外的执行程序可以调用它），因为对于频繁被执行的程序，只需要在内存中有一份代码即可。代码区通常是只读的，使其只读的原因是防止程序意外地修改了它的指令。另外，代码区还规划了局部变量的相关信息。
    
    （2）全局初始化数据区/静态数据区（initialized data segment/data segment）。该区包含了在程序中明确被初始化的全局变量、静态变量（包括全局静态变量和局部静态变量）和常量数据（如字符串常量）。例如，一个不在任何函数内的声明（全局数据）：
    
    int   maxcount = 99;
    使得变量maxcount根据其初始值被存储到初始化数据区中。
    
    static mincount=100;
    这声明了一个静态数据，如果是在任何函数体外声明，则表示其为一个全局静态变量，如果在函数体内（局部），则表示其为一个局部静态变量。另外，如果在函数名前加上static，则表示此函数只能在当前文件中被调用。
    
    （3）未初始化数据区。亦称BSS区（uninitialized data segment），存入的是全局未初始化变量。BSS这个叫法是根据一个早期的汇编运算符而来，这个汇编运算符标志着一个块的开始。BSS区的数据在程序开始执行之前被内核初始化为0或者空指针（NULL）。例如一个不在任何函数内的声明：
    
    long  sum[1000];
    将变量sum存储到未初始化数据区。
    
    图3-1所示为可执行代码存储时结构和运行时结构的对照图。一个正在运行着的C编译程序占用的内存分为代码区、初始化数据区、未初始化数据区、堆区和栈区5个部分。
    
    
    （点击查看大图）图3-1　C程序的内存布局
    （1）代码区（text segment）。代码区指令根据程序设计流程依次执行，对于顺序指令，则只会执行一次（每个进程），如果反复，则需要使用跳转指令，如果进行递归，则需要借助栈来实现。
    
    代码区的指令中包括操作码和要操作的对象（或对象地址引用）。如果是立即数（即具体的数值，如5），将直接包含在代码中；如果是局部数据，将在栈区分配空间，然后引用该数据地址；如果是BSS区和数据区，在代码中同样将引用该数据地址。
    
    （2）全局初始化数据区/静态数据区（Data Segment）。只初始化一次。
    
    （3）未初始化数据区（BSS）。在运行时改变其值。
    
    （4）栈区（stack）。由编译器自动分配释放，存放函数的参数值、局部变量的值等。其操作方式类似于数据结构中的栈。每当一个函数被调用，该函数返回地址和一些关于调用的信息，比如某些寄存器的内容，被存储到栈区。然后这个被调用的函数再为它的自动变量和临时变量在栈区上分配空间，这就是C实现函数递归调用的方法。每执行一次递归函数调用，一个新的栈框架就会被使用，这样这个新实例栈里的变量就不会和该函数的另一个实例栈里面的变量混淆。
    
    （5）堆区（heap）。用于动态内存分配。堆在内存中位于bss区和栈区之间。一般由程序员分配和释放，若程序员不释放，程序结束时有可能由OS回收。
    
    之所以分成这么多个区域，主要基于以下考虑：
    
    一个进程在运行过程中，代码是根据流程依次执行的，只需要访问一次，当然跳转和递归有可能使代码执行多次，而数据一般都需要访问多次，因此单独开辟空间以方便访问和节约空间。
    
    临时数据及需要再次使用的代码在运行时放入栈区中，生命周期短。
    
    全局数据和静态数据有可能在整个程序执行过程中都需要访问，因此单独存储管理。
    
    堆区由用户自由分配，以便管理。
    
    下面通过一段简单的代码来查看C程序执行时的内存分配情况。相关数据在运行时的位置如注释所述。
    
    //main.cpp 
    int a = 0;    //a在全局已初始化数据区 
    char *p1;    //p1在BSS区（未初始化全局变量） 
    main() 
    {
    int b;    //b在栈区
    char s[] = "abc"; //s为数组变量，存储在栈区，
    //"abc"为字符串常量，存储在已初始化数据区
    char *p1，p2;  //p1、p2在栈区
    char *p3 = "123456"; //123456\0在已初始化数据区，p3在栈区 
    static int c =0；  //C为全局（静态）数据，存在于已初始化数据区
    //另外，静态数据会自动初始化
    p1 = (char *)malloc(10);//分配得来的10个字节的区域在堆区
    p2 = (char *)malloc(20);//分配得来的20个字节的区域在堆区
    free(p1);
    free(p2);
    } 
    2．内存分配方式
    
    在C语言中，对象可以使用静态或动态的方式分配内存空间。
    
    静态分配：编译器在处理程序源代码时分配。
    
    动态分配：程序在执行时调用malloc库函数申请分配。
    
    静态内存分配是在程序执行之前进行的因而效率比较高，而动态内存分配则可以灵活的处理未知数目的。
    
    静态与动态内存分配的主要区别如下：
    
    静态对象是有名字的变量，可以直接对其进行操作；动态对象是没有名字的变量，需要通过指针间接地对它进行操作。
    
    静态对象的分配与释放由编译器自动处理；动态对象的分配与释放必须由程序员显式地管理，它通过malloc()和free两个函数（C++中为new和delete运算符）来完成。
    
    以下是采用静态分配方式的例子。
    
    int a=100;
    此行代码指示编译器分配足够的存储区以存放一个整型值，该存储区与名字a相关联，并用数值100初始化该存储区。
    
    以下是采用动态分配方式的例子。
    
    p1 = (char *)malloc(10*sizeof(int));//分配得来得10*4字节的区域在堆区
    此行代码分配了10个int类型的对象，然后返回对象在内存中的地址，接着这个地址被用来初始化指针对象p1，对于动态分配的内存唯一的访问方式是通过指针间接地访问，其释放方法为：
    
    free(p1);
    3.1.2　栈和堆的区别
    
    前面已经介绍过，栈是由编译器在需要时分配的，不需要时自动清除的变量存储区。里面的变量通常是局部变量、函数参数等。堆是由malloc()函数（C++语言为new运算符）分配的内存块，内存释放由程序员手动控制，在C语言为free函数完成（C++中为delete）。栈和堆的主要区别有以下几点：
    
    （1）管理方式不同。
    
    栈编译器自动管理，无需程序员手工控制；而堆空间的申请释放工作由程序员控制，容易产生内存泄漏。
    
    （2）空间大小不同。
    
    栈是向低地址扩展的数据结构，是一块连续的内存区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，当申请的空间超过栈的剩余空间时，将提示溢出。因此，用户能从栈获得的空间较小。
    
    堆是向高地址扩展的数据结构，是不连续的内存区域。因为系统是用链表来存储空闲内存地址的，且链表的遍历方向是由低地址向高地址。由此可见，堆获得的空间较灵活，也较大。栈中元素都是一一对应的，不会存在一个内存块从栈中间弹出的情况。
    
    （3）是否产生碎片。
    
    对于堆来讲，频繁的malloc/free（new/delete）势必会造成内存空间的不连续，从而造成大量的碎片，使程序效率降低（虽然程序在退出后操作系统会对内存进行回收管理）。对于栈来讲，则不会存在这个问题。
    
    （4）增长方向不同。
    
    堆的增长方向是向上的，即向着内存地址增加的方向；栈的增长方向是向下的，即向着内存地址减小的方向。
    
    （5）分配方式不同。
    
    堆都是程序中由malloc()函数动态申请分配并由free()函数释放的；栈的分配和释放是由编译器完成的，栈的动态分配由alloca()函数完成，但是栈的动态分配和堆是不同的，他的动态分配是由编译器进行申请和释放的，无需手工实现。
    
    （6）分配效率不同。
    
    栈是机器系统提供的数据结构，计算机会在底层对栈提供支持：分配专门的寄存器存放栈的地址，压栈出栈都有专门的指令执行。堆则是C函数库提供的，它的机制很复杂，例如为了分配一块内存，库函数会按照一定的算法（具体的算法可以参考数据结构/操作系统）在堆内存中搜索可用的足够大的空间，如果没有足够大的空间（可能是由于内存碎片太多），就有需要操作系统来重新整理内存空间，这样就有机会分到足够大小的内存，然后返回。显然，堆的效率比栈要低得多。
    
    3.1.3　Linux数据类型大小
    
    在Linux操作系统下使用GCC进行编程，目前一般的处理器为32位字宽，下面是/usr/include/limit.h文件对Linux下数据类型的限制及存储字节大小的说明。
    
    /* We don't have #include_next.   Define ANSI  for standard 32-bit words.  */
    /* These assume 8-bit 'char's, 16-bit 'short int's,   and 32-bit 'int's and 'long int's.  */
    1．char数据类型
    
    char类型数据所占内存空间为8位。其中有符号字符型变量取值范围为?128～127，无符号型字符变量取值范围为0～255。其限制如下：
    
    /* Number of bits in a 'char'. */
    #  define CHAR_BIT 8          //所占字节数
    /* Minimum and maximum values a 'signed char' can hold.  */  //有符号字符型范围
    #  define SCHAR_MIN (-128)
    #  define SCHAR_MAX 127
    /* Maximum value an 'unsigned char' can hold.  (Minimum is 0.)  */ //无符号字符型范围
    #  define UCHAR_MAX 255
    /* Minimum and maximum values a 'char' can hold.  */
    #  ifdef __CHAR_UNSIGNED__
    #   define CHAR_MIN 0
    #   define CHAR_MAX UCHAR_MAX
    #  else
    #   define CHAR_MIN SCHAR_MIN
    #   define CHAR_MAX SCHAR_MAX
    #  endif
    2．short int数据类型
    
    short int类型数据所占内存空间为16位。其中有符号短整型变量取值范围为?32768～32767，无符号短整型变量取值范围为0～65535。其限制如下：
    
    /* Minimum and maximum values a 'signed short int' can hold.  */ // 有符号短整型范围
    #  define SHRT_MIN (-32768)
    #  define SHRT_MAX 32767
    /* Maximum value an 'unsigned short int' can hold.  (Minimum is 0.)  */// 无符号短整型范围
    #  define USHRT_MAX 65535
    3．int数据类型
    
    int类型数据所占内存空间为32位。其中有符号整型变量取值范围为?2147483648～2147483647，无符号型整型变量取值范围为0～4294967295U。其限制如下：
    
    /* Minimum and maximum values a 'signed int' can hold.  */  //整形范围
    #  define INT_MIN (-INT_MAX - 1)     
    #  define INT_MAX 2147483647
    /* Maximum value an 'unsigned int' can hold.  (Minimum is 0.)  */ //无符号整形范围
    #  define UINT_MAX 4294967295U
    4．long int数据类型
    
    随着宏__WORDSIZE值的改变，long int数据类型的大小也会发生改变。如果__WORDSIZE的值为32，则long int和int类型一样，占有32位。在Linux GCC4.0-i386版本中，默认情况下__WORDSIZE的值为32。其定义如下：
    
    //come from /usr/include/bits/wordsize.h
    #define __WORDSIZE 32
    在64位机器上，如果__WORDSIZE的值为64， long　int类型数据所占内存空间为64位。其中有长整型变量取值范围为-9223372036854775808L～3372036854775807L，无符号长整型变量取值范围为0～18446744073709551615UL。其限制如下：
    
    /* Minimum and maximum values a 'signed long int' can hold.  */ //有符号长整形范围
    #  if __WORDSIZE == 64
    #   define LONG_MAX 9223372036854775807L
    #  else
    #   define LONG_MAX 2147483647L
    #  endif
    #  define LONG_MIN (-LONG_MAX - 1L)
    /* Maximum value an 'unsigned long int' can hold.  (Minimum is 0.)  *///无符号长整形范围
    #  if __WORDSIZE == 64
    #   define ULONG_MAX 18446744073709551615UL
    #  else
    #   define ULONG_MAX 4294967295UL
    #  endif
    5．long long int数据类型
    
    在C99中，还定义了long long int数据类型。其数据类型限制如下：
    
    #  ifdef __USE_ISOC99
    /* Minimum and maximum values a 'signed long long int' can hold.  *///无符号长长整形范围
    #   define LLONG_MAX 9223372036854775807LL
    #   define LLONG_MIN (-LLONG_MAX - 1LL)
    /* Maximum value an 'unsigned long long int' can hold.  (Minimum is 0.)  *///有符号长长整形范围
    #   define ULLONG_MAX 18446744073709551615ULL
    #  endif /* ISO C99 */
    3.1.4　数据存储区域实例
    
    此程序显示了数据存储区域实例，在此程序中，使用了etext、edata和end3个外部全局变量，这是与用户进程相关的虚拟地址。
    
    在程序源代码中列出了各数据的存储位置，同时在程序运行时显示了各数据的运行位置，图3-2所示为程序运行过程中各变量的存储位置。
    
    
    图3-2　函数运行时各数据位置
    主函数源代码如下：
    
    [root@localhost linux_app]# cat mem_add.c
    #include 
    #include 
    #include 
    #include 
    extern void afunc(void);
    extern etext,edata,end;
    int bss_var;                                //未初始化全局数据存储在BSS区
    int data_var=42;                            //初始化全局数据存储在数据区
    #define SHW_ADR(ID,I) printf("the %8s\t is at adr:%8x\n",ID,&I); //打印地址宏
    int main(int argc,char *argv[])
    {
    char *p,*b,*nb;
    printf("Adr etext:%8x\t Adr edata %8x\t Adr end %8x\t\n",&etext,&edata,&end);
    printf("\ntext Location:\n");
    SHW_ADR("main",main);              //查看代码段main函数位置
    SHW_ADR("afunc",afunc);           //查看代码段afunc函数位置
    printf("\nbss Location:\n");
    SHW_ADR("bss_var",bss_var);      /查看BSS段变量位置
    printf("\ndata location:\n");
    SHW_ADR("data_var",data_var);     /查看数据段变量
    printf("\nStack Locations:\n"); 
    afunc();
    p=(char *)alloca(32);              //从栈中分配空间
    if(p!=NULL)
    {
    SHW_ADR("start",p);
    SHW_ADR("end",p+31);
    }
    b=(char *)malloc(32*sizeof(char));   //从堆中分配空间
    nb=(char *)malloc(16*sizeof(char));  //从堆中分配空间
    printf("\nHeap Locations:\n");
    printf("the Heap start: %p\n",b);   //堆起始位置
    printf("the Heap end:%p\n",(nb+16*sizeof(char)));//堆结束位置
    printf("\nb and nb in Stack\n");
    SHW_ADR("b",b);       //显示栈中数据b的位置
    SHW_ADR("nb",nb);       //显示栈中数据nb的位置
    free(b);         //释放申请的空间，以避免内存泄漏
    free(nb);         //释放申请的空间，以避免内存泄漏
    }
    子函数源代码如下：
    
    void afunc(void)
    {
    static int long level=0;          //静态数据存储在数据段中
    int      stack_var;                 //局部变量，存储在栈区
    if(++level==5)
    {
    return;
    }
    printf("stack_var is at:%p\n",&stack_var);
    //      SHW_ADR("stack_var in stack section",stack_var);
    //      SHW_ADR("Level in data section",level);
    afunc();
    }
    函数运行结果如下：
    
    [root@localhost linux_app]# gcc -o mem_add mem_add.c //编译
    [root@localhost linux_app]# ./mem_add     //运行结果
    Adr etext: 8048702       Adr edata  8049950      Adr end  804995c
    text Location:
    the     main     is at adr: 8048418
    the    afunc     is at adr: 8048611
    bss Location:
    the  bss_var     is at adr: 8049958
    data location:
    the data_var     is at adr: 804994c
    Stack Locations:
    the stack_var in stack section    is at adr:bfbf6c44
    the Level in data section         is at adr: 8049954
    the stack_var in stack section    is at adr:bfbf6c24
    the Level in data section         is at adr: 8049954
    the stack_var in stack section    is at adr:bfbf6c04
    the Level in data section         is at adr: 8049954
    the stack_var in stack section    is at adr:bfbf6be4
    the Level in data section         is at adr: 8049954
    the    start     is at adr:bfbf6c74
    the      end     is at adr:bfbf6cf0
    Heap Locations:
    the Heap start: 0x8453008
    the Heap end:0x8453040
    b and nb in Stack
    the        b     is at adr:bfbf6c70
    the       nb     is at adr:bfbf6c6c
    如果运行环境不一样，运行程序的地址与此将有差异，但是，各区域之间的相对关系不会发生变化。可以通过readelf命令来查看可执行文件的详细内容。
    
    [root@localhost yangzongde]# readelf -a memadd
    3.2 内存管理函数
    
    3.2.1　malloc/free函数
    
    Malloc()函数用来在堆中申请内存空间，free()函数释放原先申请的内存空间。Malloc()函数是在内存的动态存储区中分配一个长度为size字节的连续空间。其参数是一个无符号整型数，返回一个指向所分配的连续存储域的起始地址的指针。当函数未能成功分配存储空间时（如内存不足）则返回一个NULL指针。
    
    由于内存区域总是有限的，不能无限制地分配下去，而且程序应尽量节省资源，所以当分配的内存区域不用时，则要释放它，以便其他的变量或程序使用。
    
    这两个函数的库头文件为：
    
    ＃include
    函数定义如下：
    
    void *malloc(size_t　size)   //返回类型为空指针类型
    void free(void *ptr)
    例如：
    
    int *p1,*p2;
    p1=(int *)malloc(10*sizeof(int));
    p2=p1;
    ……
    free(p2) ;      /*或者free(p1)*/ 
    p1=NULL;       /*或者p2=NULL */
    malloc()函数返回值赋给p1，又把p1的值赋给p2，所以此时p1，p2都可作为free函数的参数。使用free()函数时，需要特别注意下面几点：
    
    （1）调用free()释放内存后，不能再去访问被释放的内存空间。内存被释放后，很有可能该指针仍然指向该内存单元，但这块内存已经不再属于原来的应用程序，此时的指针为悬挂指针（可以赋值为NULL）。
    
    （2）不能两次释放相同的指针。因为释放内存空间后，该空间就交给了内存分配子程序，再次释放内存空间会导致错误。也不能用free来释放非malloc()、calloc()和realloc()函数创建的指针空间，在编程时，也不要将指针进行自加操作，使其指向动态分配的内存空间中间的某个位置，然后直接释放，这样也有可能引起错误。
    
    （3）在进行C语言程序开发中，malloc/free是配套使用的，即不需要的内存空间都需要释放回收。
    
    下面是使用这两个函数的一个例子。
    
    [root@localhost yangzongde]# cat malloc_example.c 
    #include               //printf()    //(1)头文件信息
    #include              //malloc()    //(2)
    int main(int argc,char* argv[],char* envp[])   //(3)
    {
    int count;
    int* array; 
    if((array=(int *)malloc(10*sizeof(int)))==NULL)  //(4)分配空间
    {
    printf("malloc memory unsuccessful");
    exit(1);
    }
    for (count=0;count<10;count++)      //(5) 赋值
    {
    *array=count;
    array++;
    }
    for(count=9;count>=0;count--)                  //(6)赋值
    {
    array--;
    printf("%4d",*array);
    }
    printf("\n");
    free(array);        //(7)释放空间
    array=NULL;       //(8)将指针置为空，避免不安全访问
    exit (0);
    } 
    [root@localhost yangzongde]# gcc -o malloc_example malloc_example.c  //编译
    [root@localhost yangzongde]# ./malloc_example       //运行
    9   8   7   6   5   4   3   2   1   0
    在以上程序中，（1）句中包含stdio.h头文件，从而在后面可以调用printf()函数。（2）句中包含stdlib.h头文件，其是malloc()函数的头文件。（3）句为函数的入口位置，此处采用Linux下编程标准，返回值为int型，argc为参数个数， argv[]为参数，envp[]存放的是所有环境变量。（4）句动态分配了10个整型存储区域，此语句可以分为以下几步。
    
    ① 分配10个整型的连续存储空间，并返回一个指向其起始地址的整型指针。
    
    ② 把此整型指针地址赋给array。
    
    ③ 检测返回值是否为NULL。
    
    （5）、（6）句为数组赋值并打印输出，以免内存泄漏。（7）句调用free()函数释放内存空间。（8）句将一个NULL指针传递给array，虽然在很多情况下可以不用此句，但这样处理可以避免此指针成为野指针。
    
    在C++中，使用new和delete运算符来实现内存的分配和释放，使用new/delete运算符实现内存管理比使用malloc/free函数更有优越性。new/delete运算符定义如下：
    
    static void* operator new(size_t sz);     //new运算符
    static void  operator delete(void* p);      //delete运算符
    下面是一段C++程序代码：
    
    void UseNewDelete(void)
    {
    Obj  *a = new Obj;           //申请动态内存并且初始化
    //…
    delete a;                   //清除并且释放内存
    }
    下面详细介绍C++中new/delete运算符的使用方法。
    
    class A
    {
    public:
    A()  {   cout<<"A is here!"<<ENDL;&NBSP;&NBSP; 构造函数
    ～A() {   cout<<"A is dead!"<<ENDL;&NBSP;&NBSP; }  ="" 析构函数
    private:
    int i;
    };
    A* pA=new A;     //调用new运算符申请空间
    delete pA;      //删除pA 
    其中，语句new A完成了以下两个功能：
    
    （1）调用运算符new，在自由存储区分配一个sizeof(A)大小的内存空间。
    
    （2）调用构造函数A()，在这块内存空间上初始化对象。
    
    当然，delete pA完成相反的两件事：
    
    （1）调用析构函数～A()，销毁对象。
    
    （2）调用运算符delete，释放内存。
    
    由此可以看出，运算符new和delete提供了动态分配和释放存储区的功能。它们的作用相当于C语言的malloc()和free()函数，但是性能更为优越。使用new比使用malloc（）有以下几个优点：
    
    （1）new自动计算要分配给对象的内存空间大小，不使用sizeof运算符，简单，而且可以避免错误。
    
    （2）自动地返回正确的指针类型，不用进行强制类型转换。
    
    （3）用构造函数给分配的对象进行初始化。
    
    但是，使用malloc函数和new分配内存的时候，本身并没有对这块内存空间做清零等任何动作。因此，申请内存空间后，其返回的新分配的内存是没有零填充的，程序员需要使用memset()函数来初始化内存。
    
    3.2.2　realloc--更改已经配置的内存空间
    
    realloc()函数用来从堆上分配内存，当需要扩大一块内存空间时，realloc()试图直接从堆上当前内存段后面的字节中获得更多的内存空间，如果能够满足，则返回原指针；如果当前内存段后面的空闲字节不够，那么就使用堆上第一个能够满足这一要求的内存块，将目前的数据复制到新的位置，而将原来的数据块释放掉。如果内存不足，重新申请空间失败，则返回NULL。此函数定义如下：
    
    void *realloc(void *ptr,size_t size)
    参数ptr为先前由malloc、calloc和realloc所返回的内存指针，而参数size为新配置的内存大小。其库头文件为：
    
    ＃include<stdlib.h>
    当调用realloc()函数重新分配内存时，如果申请失败，将返回NULL，此时原来指针仍然有效，因此在程序编写时需要进行判断，如果调用成功，realloc()函数会重新分配一块新内存，并将原来的数据拷贝到新位置，返回新内存的指针，而释放掉原来指针（realloc()函数的参数指针）指向的空间，原来的指针变为不可用（即不需要再释放，也不能再释放），因此，一般不使用以下语句：
    
    ptr=realloc(ptr,new_amount)
    如果内存减少，malloc仅仅改变索引信息，但并不代表被减少的部分还可以访问，这一部分内存将交给系统内存分配子程序。
    
    下面是一个使用relloc函数的实例。
    
    [root@localhost yangzongde]# cat realloc_example.c 
    #include <stdio.h>
    #include <stdlib.h>
    int main (int argc,char* argv[],char* envp[])   //(1)主函数
    {
    int input;
    int n;
    int *numbers1;
    int *numbers2;
    numbers1=NULL;
         if((numbers2=(int *)malloc(5*sizeof(int)))==NULL) //(2)numbers2指针申请空间
    {
    printf("malloc memory unsuccessful");
    //free(numbers2);
    numbers2=NULL;
    exit(1);
    }
    for (n=0;n<5;n++)       //(3)初始化
    {
    *(numbers2+n)=n;
    printf("numbers2's data: %d\n",*(numbers2+n));
    }
         printf("Enter an integer value you want to remalloc ( enter 0 to stop)\n");//(4)新申请空间大小　
    scanf ("%d",&input);
    
    numbers1=(int *)realloc(numbers2,(input+5)*sizeof(int));  //(5)重新申请空间
    if (numbers1==NULL) 
    { 
    printf("Error (re)allocating memory"); 
    exit (1); 
    }
         for(n=0;n<5;n++)       //(6)这5个数是从numbers2拷贝而来
    {
    printf("the numbers1s's data copy from numbers2: %d\n",*(numbers1+n));
    }
         for(n=0;n<input;n++)       //(7)新数据初始化
    {
    *(numbers1+5+n)=n*2;
    printf ("nummber1's new data: %d\n",*(numbers1+5+n)); // numbers1++;
    }
    printf("\n");
    free(numbers1);       //(8)释放numbers1
    numbers1=NULL;
    // free(numbers2);     //(9)不能再释放numbers2
    return 0;
    } 
    [root@localhost yangzongde]# gcc -o realloc_example realloc_example.c 
    [root@localhost yangzongde]# ./realloc_example 
    numbers2's data: 0
    numbers2's data: 1
    numbers2's data: 2
    numbers2's data: 3
    numbers2's data: 4
    Enter an integer value you want to remalloc ( enter 0 to stop) //重新申请空间
    5  
    the numbers1s's data copy from numbers2: 0
    the numbers1s's data copy from numbers2: 1
    the numbers1s's data copy from numbers2: 2
    the numbers1s's data copy from numbers2: 3
    the numbers1s's data copy from numbers2: 4
    nummber1's new data: 0
    nummber1's new data: 2
    nummber1's new data: 4
    nummber1's new data: 6
    nummber1's new data: 8
    此程序是一个简单的重新申请内存空间的实例，（1）为函数入口，前面已经介绍过。（2）从堆空间中申请5个int空间，将返回地址赋给numbers2，如果返回值为NULL，将返回错误信息，释放numbers2并退出。（3）为新申请的空间初始化。（4）输入需要增加的内存数量。（5）调用realloc()函数重新申请内存空间，重新申请内存空间大小为原有空间大小加上用户输入的内存空间数。如果申请失败，将返回NULL，此时numbers2仍然有效。如果申请成功，将重新分配一块大小合适的空间，并将新空间首地址赋给numbers1，同时将numbers2所指向的5个空间的数据复制到新的内存空间中，释放掉原来numbers2所指向的内存空间。（6）打印从numbers2所指向的原空间拷贝的数据，（7）句对新增加的空间进行初始化。（8）句释放number1所指向的新申请空间。（9）为注释掉的代码，提示读者此时对原空间再次释放，因为第（5）已经完成了这一操作。
    
    3.2.3　其他内存管理函数calloc和alloca
    
    1．calloc函数
    
    calloc是malloc函数的简单包装，它的主要优点是把动态分配的内存进行初始化，全部清零。其操作及语法类似malloc()函数。
    
    ptr=(struct data *)calloc (count,sizeof(strunt data)) //申请并初始化空间
    下面是这个函数的实现描述：
    
    void *calloc(size_t nmemb,size_t size)
    {
    void *p;
    size_t total;
    total=nmemb *size;
    p=malloc(total);         //申请空间
    if(p!=NULL)
    memset(p,'\0',total);      //将其实始化为\0
    return p;
    }
    2．alloca函数
    
    alloca()函数用来在栈中分配size个字节的内存空间，因此函数返回时会自动释放掉空间。alloca函数定义及库头文件如下：
    
    /* Allocate a block that will be freed when the calling function exits.  */
    extern void *alloca (size_t __size) __THROW;   //从栈中申请空间
    返回值：若分配成功返回指针，失败则返回NULL。
    
    它与malloc()函数的区别主要在于：
    
    alloca是向栈申请内存，无需释放，malloc申请的内存位于堆中，最终需要函数free来释放。
    
    malloc函数并没有初始化申请的内存空间，因此调用malloc()函数之后，还需调用函数memset初始化这部分内存空间；alloca则将初始化这部分内存空间为0。

[http_blog.csdn.net_youoran_article_details_10990815]: http://blog.csdn.net/youoran/article/details/10990815