c语言动态分配内存空间(转)

转自:http://c.biancheng.net/cpp/html/137.html

malloc函数

头文件

#include <stdlib.h>

malloc() 函数用来动态地分配内存空间,其原型为：

void* malloc (size_t size);

【参数说明】size 为需要分配的内存空间的大小，以字节（Byte）计。

【函数说明】malloc() 在堆区分配一块指定大小的内存空间，用来存放数据。这块内存空间在函数执行完成后不会被初始化，它们的值是未知的。如果希望在分配内存的同时进行初始化，请使用 calloc() 函数。

【返回值】分配成功返回指向该内存的地址，失败则返回 NULL。

由于申请内存空间时可能有也可能没有，所以需要自行判断是否申请成功，再进行后续操作。

如果 size 的值为 0，那么返回值会因标准库实现的不同而不同，可能是 NULL，也可能不是，但返回的指针不应该再次被引用。

注意：函数的返回值类型是 void *，void 并不是说没有返回值或者返回空指针，而是返回的指针类型未知。所以在使用 malloc() 时通常需要进行强制类型转换，将 void 指针转换成我们希望的类型，例如：

char *ptr = (char *)malloc(10); //分配10个字节的内存空间，用来存放字符

动态内存分配举例：

    #include <stdio.h>  /* printf, scanf, NULL */
    #include <stdlib.h>  /* malloc, free, rand, system */
    int main ()
    {
        int i,n;
        char * buffer;
        printf ("输入字符串的长度：");
        scanf ("%d", &i);
        buffer = (char*)malloc(i+1);  // 字符串最后包含 \0
        if(buffer==NULL) exit(1);  // 判断是否分配成功
        // 随机生成字符串
        for(n=0; n<i; n++)
            buffer[n] = rand()%26+'a';
        buffer[i]='\0';
        printf ("随机生成的字符串为：%s\n",buffer);
        free(buffer);  // 释放内存空间
        system("pause");
        return 0;
    }

运行结果：
输入字符串的长度：20
随机生成的字符串为：phqghumeaylnlfdxfirc

该程序生成一个指定长度的字符串，并用随机生成的字符填充。字符串的长度仅受限于可用内存的长度。

realloc函数

在C语言中，良好的编程习惯要求一个函数只做一件事，如果一个函数实现了若干功能，可以说基本是一个糟糕的设计。

C语言 realloc() 函数位于 stdlib.h 头文件中，其原型为：

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

realloc() 会将 ptr 所指向的内存块的大小修改为 size，并将新的内存指针返回。

设之前内存块的大小为 n，如果 size < n，那么截取的内容不会发生变化，如果 size > n，那么新分配的内存不会被初始化。

如果 ptr = NULL，那么相当于调用 malloc(size)；如果 size = 0，那么相当于调用 free(ptr)。

如果 ptr 不为 NULL，那么他肯定是由之前的内存分配函数返回的，例如 malloc()、calloc()或realloc()。

如果 ptr 所指的内存块被移动，那么会调用 free(ptr)。

看吧，一个简单的 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
实际上，malloc(0)是合法的语句，会返还一个合法的指针，且该指针可以通过free去释放。这就造成了很多人对realloc()的错误理解，认为当size为0时，实际上realloc()也会返回一个合法的指针，后面依然需要使用free去释放该内存。

    void *new_ptr = realloc(old_ptr, new_size);
    //其它代码
    free(new_ptr);

由于错误的认识，不去检验new_size是否为0，还是按照new_size不为0的逻辑处理，最后并free(new_ptr）。这里就引入了double free的问题，造成程序崩溃。

calloc函数

头文件

#include <stdlib.h>

calloc() 函数用来动态地分配内存空间并初始化为 0，其原型为：

    void* calloc (size_t num, size_t size);

calloc() 在内存中动态地分配 num 个长度为 size 的连续空间，并将每一个字节都初始化为 0。所以它的结果是分配了 num*size 个字节长度的内存空间，并且每个字节的值都是0。

【返回值】分配成功返回指向该内存的地址，失败则返回 NULL。

如果 size 的值为 0，那么返回值会因标准库实现的不同而不同，可能是 NULL，也可能不是，但返回的指针不应该再次被引用。

注意：函数的返回值类型是 void *，void 并不是说没有返回值或者返回空指针，而是返回的指针类型未知。所以在使用 calloc() 时通常需要进行强制类型转换，将 void 指针转换成我们希望的类型，例如：

char *ptr = (char *)calloc(10, 10); //分配100个字节的内存空间

calloc() 与 malloc() 的一个重要区别是：calloc() 在动态分配完内存后，自动初始化该内存空间为零，而 malloc() 不初始化，里边数据是未知的垃圾数据。下面的两种写法是等价的：

    // calloc() 分配内存空间并初始化
    char *str1 = (char *)calloc(10, 2);
    // malloc() 分配内存空间并用 memset() 初始化
    char *str2 = (char *)malloc(20);
    memset(str2, 0, 20);

代码示例：

    #include <stdio.h>
    #include <stdlib.h>
    int main ()
    {
        int i,n;
        int * pData;
        printf ("要输入的数字的数目：");
        scanf ("%d",&i);
        pData = (int*) calloc (i,sizeof(int));
        if (pData==NULL) exit (1);
        for (n=0;n<i;n++)
        {
            printf ("请输入数字 #%d：",n+1);
            scanf ("%d",&pData[n]);
        }
        printf ("你输入的数字为：");
        for (n=0;n<i;n++) printf ("%d ",pData[n]);

        free (pData);
        system("pause");
        return 0;
    }

运行结果：
要输入的数字的数目：4
请输入数字 #1：126
请输入数字 #2：343
请输入数字 #3：45
请输入数字 #4：234
你输入的数字为：126 343 45 234

上面的程序会将你输入的数字存储起来，然后输出。因为在程序运行时根据你的需要来动态分配内存，所以每次运行程序你可以输入不同数目的数字。