注册 登录  
 加关注
   显示下一条  |  关闭
温馨提示!由于新浪微博认证机制调整,您的新浪微博帐号绑定已过期,请重新绑定!立即重新绑定新浪微博》  |  关闭

饥民2011

一直在搬砖

 
 
 

日志

 
 
 
 

C语言 利用malloc()和realloc()动态分配内存  

2013-03-31 17:24:38|  分类: c/c++ |  标签: |举报 |字号 订阅

  下载LOFTER 我的照片书  |


1. C语言定义1个数组的时候, 必须同时指定它的长度.


例如: int a[5]={1,2,3,4,5};    //合法
         int b[6];   //合法

         int c[];    //错误   因为没有指定长度

但是下面语句是正确, 它隐形定义了数组的长度, 就是赋值元素的个数
         int d[] ={4,5,6,7,8,9}    //合法 长度为6


2. 静态数组

        什么是静态数组,  其实上面合法定义的数组都是静态数组.
        静态数组并不是指数组里面的元素是静态的,  上面的数组都可以修改指定元素的指
        而是指数组的元素个数是静态的,  也就是某1个静态数组一旦被定义, 那么在程序运行结束的这段时间里它的长度的都是不变的.
        也就是说当你定义1个 静态数组a[5]
         int a[5]={1,2,3,4,5};
        
         你就不能修改a 的长度了.

3.动态定义数组的个数

         有时我们需要1个数组, 但是数组的元素个数不是固定的, 是个变量,  那么我们是否可以利用如下语句
         int i = 7;
         int a[i];    //定义1个长度为i的数组?
        
         上面的写法可以能在java .net 里面是可行的, 但是c语言里是不合法的, 不能这样定义1个数组.  数组的长度必须是1个常量.

         但是经本人测试,  上面的写法已经被最新的gcc支持了 囧


         正确的写法:
                int len =7;
                int * a = (int *) malloc (sizeof(int) * len);

                int * a 就是顶定义1个int类型的指针啦.
                其中 sizeof(int) 就是4 (byte) 啦  ,  
                 malloc (sizeof(int) * len)        就是在内存划出 4* len = 28个字节的内存, 并返回第1个字节(最小内存单位)的地址
               
                malloc函数是返回1个地址的, 但是只有地址是没有意义的.  因为要把这个地址赋值给1个int类型指针的话,要将其格式化.

                所以malloc 前面要加上(int *) 就是把malloc 返回的地址格式化成1个 int类型的地址.

                可以理解成这个int类型的地址是4个字节1个单位的,  只要获得这个地址, 就获得后面3个地址的内容啦.

                所以上面蓝色的语句就的得到了1个指
         正确的写法:向 1个 长度为7的int类型数组指针a.

                后面就可以把a 当作一般的数组名a来处理了.

                最后注意一点, 使用malloc函数 , 必须引用malloc.h  或者 stdlib.h头文件.

4.动态数组占用的释放
                 定义1个静态数组int a[7],  那么在函数结束被调用或程序结束前的时间里, 这28个字节是容易被这个数组占用的.
 
                  而动态分配(malloc函数分配)的内存 在程序运行的时间内可以被释放.  然后被其他对象使用.

                  例如:
                 int len =7;
                 int * a = (int *) malloc (sizeof(int) * len);
                        // 这里可以把数组a 当作普通数组来使用

                  free(a);   //释放这个数组a所占的28个字节的内存.
                                  //注意 是释放指针a所指向的内存, 而不是释放指针a本身占用的内存.
                                  // 注意不能释放静态变量或数组的空间.
                                  // 注意 经由malloc 分配的动态内存. 必须手动释放

                   这样的话. 优点很明显. 因为可以动态分配和释放, 比其静态定义要节省内存啊.


5.动态数组长度的增加.
               
这个就是动态数组跟静态数组区别最大的地方了, 动态数组的长度可以改变啊.
                接上面的例子
               

                  int len =7;
                 int * a = (int *) malloc (sizeof(int) * len);

                 上面定义了1个长度为7 的动态数组,  这时我发现这个数组不够用了, 想给它加1个元素,值是40,也就是令他的长度+1
              
                 直接
                 *(a+7) = 40; //合法, 也可能通过编译和执行.  但是这个是错误的写法.

               
为什么说上面的写法是错误的呢,  因为我们只给指针a 分配了1个字节为28byte的连续内存空间.
                就是 从a[0] 到 a[6]了
                那么a[7]是什么呢,  明显就是a[6]后面接着的4个字节的内存空间啊. 
               但是这个空间有可能被其他对象或其他程序正使用中的, 以后也可能被使用,  这样未执行分配指令就直接使用的话就很有可能改变了其他对象或程序中的内存内容,  这就是所谓的不安全行为.

               
那应该怎么做?
               就用到另一函数  realloc()   重新分配指针a所占的长度.

                  例如:
                

                 int len =7;
                 int * a = (int *) malloc (sizeof(int) * len);
                 len++;
                 int * aold = a;            //重新分配前保存a的地址
                 a = (int *)realloc(sizeof(int)* len);   //重新分配28+4 = 32字节内存给数组a
                 if (aold != a){            //如果a的地址改变了, 代表内存在另外1个地方划分1个新的内存空间
                      free(aold);          //把旧空间释放
                 }



                 我们来分析一下上面4条语句
                 前面两句定义了1个长度为7的int 类型数组, 每个元素的字节长度是4, 所以共占28byte 内存.
                 第3句长度变量+1
                 第4句 分两种情况:
                            1) 假如数组a 内存里接着的4个字节还没被其他对象或程序占用, 那么就直接把后面4个字节加给数组a, 数组前面7个旧的元素的值不变,  数组a的头部地址也不变.

                             2) 假如数组 a内存里接着的4个字节已经被占用了, 那么realloc 函数会在内存其他地方找1个连续的32byte 内存空间, 并且把数组a的7个旧元素的值搬过去,  所以数组a的7个旧元素的值也不变, 但是数组a的头部地址变化了.  但是这时我們需要把旧的内存空间释放.

                 但最终效果都一样的, 就似是我们可以动态地给动态数组a增加多1个元素的内存空间.

                  注意: realloc 函数不能用在静态数组的指针上,  即使通过编译. 执行时也会出错.
                

 5.一个简单的例子程序:

int malloc_3(){
    int len = 7;
    int * a = (int *)malloc(sizeof(int) * len);
    int i;
    for (i=0; i <len ; i++){
        a[i] = (i+1)*2;
    }   
    i = p_array_int_1(a,len); //a function to print the array which defined by user   
    printf("address is %p\n", a);
   
    len++;
    //a = (int *)realloc(a, sizeof(int)* (len));
    i = re_malloc(&a, len);
    a[len-1]= 40;
    i = p_array_int_1(a,len); //a function to print the array which defined by user   
    printf("address is %p\n", a);

    free(a);
    return 0;
}

int re_malloc(int ** pa, int len){
    int * pold;
    *pa = (int *)realloc(*pa, sizeof(int)* (len));
    if (pold != *pa){
        free(pold);
    }
    return 0;
}

 
 

输出:
C语言  利用malloc()和realloc()动态分配内存 - 饥民 - 饥民2011
 
  评论这张
 
阅读(907)| 评论(0)
推荐 转载

历史上的今天

在LOFTER的更多文章

评论

<#--最新日志,群博日志--> <#--推荐日志--> <#--引用记录--> <#--博主推荐--> <#--随机阅读--> <#--首页推荐--> <#--历史上的今天--> <#--被推荐日志--> <#--上一篇,下一篇--> <#-- 热度 --> <#-- 网易新闻广告 --> <#--右边模块结构--> <#--评论模块结构--> <#--引用模块结构--> <#--博主发起的投票-->
 
 
 
 
 
 
 
 
 
 
 
 
 
 

页脚

网易公司版权所有 ©1997-2017