精华内容
下载资源
问答
  • C语言二维数组动态内存分配

    千次阅读 2019-09-19 20:57:15
    总结两种二维数组动态分配内存方法

    今天晚上写一个给二维数组动态分配内存的函数,现在总结一下两种方法,假定要定义一个2592行5列的double型数组,直接定义的话可能会引起栈内存溢出,尤其是同时定义多个数组时,这种情况更容易发生。
    第一种分配方法,不连续分配内存
    在这里插入图片描述
    第二种方法,连续内存分配
    在这里插入图片描述

    展开全文
  • 对于二维数组和二维指针的内存的分配 这里首选说一下一维指针和一维数组的内存分配情况。 一维: 数组:形如int a[5];这里定义了一个一维数组a,并且数组的元素个数是5,这里的a是这五个元素的整体表示,也就是...

    对于二维数组和二维指针的内存的分配

    这里首选说一下一维指针和一维数组的内存分配情况。

    一维:

    数组:形如int  a[5];这里定义了一个一维数组a,并且数组的元素个数是5,这里的a是这五个元素的整体表示,也就是通过a我们能找到这五个元素。注意:a是代表数组第一个元素的首地址。&a是代表数组的地址,虽然它们的值相同。

    指针: int *p = NULL;这里p是一个指针,它指向的是计算

    机内一块存储int类型的内存。P = a;就是让p等于刚才申请的数组的第一个元素的地址。所以通过p我们也能找到那5个元素所以P[i]跟a[i]的作用一样。

    注意:

    1:int *p = NULL; p的大小在32位机器是4,即使p=a;之后p的sizeof(p)仍然等于4。

    2:在声明之后,数组必须分配内存进行初始化。而指针一般是动态分配其指向的内存。

    3:不要混淆指针和数组,指针就是指针,数组就是数组,只是数组在一定条件下可以转换成指针。不要将指针和数组混淆。(例如:指针有++,--操作,数组则不可以)。

    一维指针的动态内存分配:

    int *p = NULL;

    p = new int[N];

    千万别忘了delete

    delete [] p;

    p = NULL;

    二维数组的内存分配

    int a[2][3];   这里分配了一个2X3=6个int大小的数组。二维数组的第二个维度3不能省略。

    二维数组的内存在计算机内也是连续的一片地址,只不过每3个元素构成一个一维数组a[i],这里的a[i]代表维度为3的数组的第一个元素的地址。所以a[i][j]的访问跟a[i]的访问也就清楚了。这里的a[i]其实是一个一维数组的第一个元素的地址。

    对于二维数组做实参,我们通常用一维指针处理,例如:

     1 #include <iostream>
     2 void test(int *p)
     3 {
     4     for (int i = 0;i<3;++i)
     5     {
     6         for(int j = 0;j<3;++j)
     7         {
     8             std::cout<<*(p+3*i+j); //一维处理
     9         }
    10     }
    11 }
    12 int main(void)
    13 {
    14     int a[3][3]={1,2,3,4,5,6,7,0,0};
    15     test((int*)a);     //将二维数组当做一维处理
    16     system("pause");
    17     return 0;
    18 }

    这些想必书上讲的都非常清楚。

     

    二维数组的C++动态内存分配。

    二维指针的动态数组分配:二维指针类似指针数组的分配

    int **p;

     1 #include <iostream>
     2 int main(void)
     3 {
     4     int **p = NULL;       //这里申请一个3x4的二维数组
     5     p = new int *[3];     //分配一维指针,分配三个int* 类型的一维指针。 
     6     for (int i = 0;i < 3; ++i)
     7     {
     8         p[i] = new int[4];
     9     }
    10     for (int i = 0; i < 3; ++i)
    11     {
    12         for(int j = 0; j < 4 ; ++j)
    13         {
    14             p[i][j] = i*j;
    15             std::cout<<p[i][j]<<" ";
    16         }
    17         std::cout<<std::endl;
    18     }
    19     
    20     for (int i = 0;i < 3;++i)    //释放
    21     {
    22         delete [] p[i];
    23     }
    24     delete [] p;
    25     system("pause");
    26     return 0;
    27 }

     

    指针数组的动态内存分配

    指针数组的动态内存分配只需要对指针数组的数组元素指针分别分配内存即可,比二维指针的分配少了一个环节。

     1 #include <iostream>
     2 int main(void)
     3 {
     4     int *a[3];    //申请含有三个int* 类型的指针数组
     5                   //跟二维指针不同的是,这里数组a不用手动申请内存
     6     for (int i = 0;i < 3;++i)  //申请一个3x4的空间
     7     {
     8         a[i] = new int[4];
     9     }
    10     for (int i = 0; i<3 ;++i)
    11     {
    12         for (int j = 0; j<4; ++j)
    13         {
    14             a[i][j] = i*j;
    15             std::cout<<a[i][j]<<" ";
    16         }
    17         std::cout<<std::endl;
    18     }
    19 
    20     for (int i = 0;i <3 ;++i)  //分别释放三个指针元素,由于数组在栈区,会自动释放
    21     {
    22         delete [] a[i];
    23     }
    24     system("pause");
    25     return 0;
    26 }

     

    数组指针的动态内存分配

    数组指针就是指向数组的指针,说白了就是指向一个数组整体,因此分配的时候直接申请一片内存地址即可。跟二维数组的静态分配类似。

    1 // Karllen 
    2 int main(void)
    3 {
    4     int (*a)[4];     //这里的4是第二维的维度,a的增量的基数为4个int
    5     a = new int[3][4];      
    6     delete []a;
    7         a = NULL;
    8     return 0;
    9 }

    用的最多的就是上面的几种方法。一次性分配二维数组的内存还有多种方法可以实现。我也是刚接触这些东西,希望大家能提出不正确的地方。共勉!!!

    转载于:https://www.cnblogs.com/Forever-Kenlen-Ja/p/3753566.html

    展开全文
  • C/C++中的二维数组动态内存分配与释放 C语言: //二维数组动态数组分配和释放 //数组指针的内存分配和释放 //方法一 char (*a)[N];//指向数组的指针 a = (char (*)[N])malloc(sizeof(char [N]) * m); ...
    C/C++中的二维数组动态内存分配与释放

    C语言:

    //二维数组动态数组分配和释放  
    //数组指针的内存分配和释放  
    //方法一  
    char (*a)[N];//指向数组的指针  
    a = (char (*)[N])malloc(sizeof(char [N]) * m);  
      
    free(a);   
      
    //方法二  
    char **a;  
    int i;  
    a = (char **)malloc(sizeof(char *) * m);//分配指针数组  
    for(i=0; i<m; i++)  
        a[i] = (char *)malloc(sizeof(char) * n);//分配每个指针所指向的数组  
      
    for(i=0; i<m; i++)  
        free(a[i]);  
    free(a);   
      
    //方法三  
    char **a;  
    int i;  
    a = (char **)malloc(sizeof(char *) * m);//分配指针数组  
    a[0] = (char *)malloc(sizeof(char) * m * n);//一次性分配所有空间  
    for(i=1; i<m; i++)  
        a[i] = a[i-1] + n;  
      
    free(a[0]);  
    free(a);   
      
      
    //指针数组的内存分配和释放  
    //方法一  
    char* a[M];//指针的数组  
    int i;  
    for(i=0; i<M; i++)  
        a[i] = (char *)malloc(sizeof(char) * n);  
      
    for(i=0; i<M; i++)  
        free(a[i]);   
      
    //方法二  
    char* a[M];//指针的数组  
    int i;  
    a[0] = (char *)malloc(sizeof(char) * M * n);  
    for(i=1; i<M; i++)  
        a[i] = a[i-1] + n;  
      
    free(a[0]);   

    C++:

    //二维数组动态数组分配和释放  
    //数组指针的内存分配和释放  
    //方法一  
    char (*a)[N];//指向数组的指针  
    a = new char[m][N];  
      
    delete[] a;   
      
    //方法二  
    char **a;  
    a = new char* [m];//分配指针数组  
    for(int i=0; i<m; i++)  
        a[i] = new char[n];//分配每个指针所指向的数组  
      
    for(i=0; i<m; i++)  
        delete[] a[i];  
    delete[] a;   
      
      
    //指针数组的内存分配和释放  
    //方法一  
    char **a;  
    a = new char* [m];  
    a[0] = new char[m * n];//一次性分配所有空间  
    for(int i=1; i<m; i++)  
        a[i] = a[i-1] + n;//分配每个指针所指向的数组  
      
    delete[] a[0];  
    delete[] a;   
      
    //方法二  
    char* a[M];//指针的数组  
    for(int i=0; i<M; i++)  
       a[i] = new char[n];  
      
    for(i=0; i<M; i++)  
       delete[] a[i];   
      
    //方法三  
    char* a[M];//指针的数组  
    a[0] = new char[M*n];  
    for(int i=1; i<M; i++)  
        a[i] = a[i-1] + n;  
      
    delete[] a[0];  

    注意:

    new和delete要注意配对使用,即有多少个new就有多少个delete,这样才可以避免内存泄漏!

    From:http://blog.csdn.net/huazhigang/article/details/11745551
    展开全文
  • 维数组动态内存分配 #include "stdafx.h" #include <iostream> using namespace std; int main() { int length,i; int *p; cin>>length; p=new int[length]; for(i=...

    一维数组的动态内存分配

    #include "stdafx.h"
    #include <iostream> 
    using namespace std;
    
    int main() 
    { 
        int length,i; 
        int *p; 
        cin>>length; 
        p=new int[length]; 
        for(i=0;i<length;i++) 
        { 
            p[i]=i;     //不要写成*p[i]=i; 
            cout<<p[i]<<endl;   //不要写成cout<<*p[i]<<endl; 
        } 
        delete []p;
        p=0;
        return 0; 
    }

    2、利用指针的指针实现二维数组的动态存储

    int **p;
    
    .....
    
        p = new int*[n];  //申请行空间
    for (i=0;i<n;i++)
    {
        p[i]=new int [n]; //申请列空间
    }

    3、动态分配内存的指针数组

    #include "stdafx.h"
    #include <iostream>
    using namespace std;
    int main()
    {
        int (*p)[2]=new int[2][2];
        int i,j;
        int a[2][2]={1,2,3,4};
        for (i=0;i<2;i++)
            for (j=0;j<2;j++)
            {
                p[i][j]=a[i][j];
            }
            //p=a;
            cout<<"p[0][0]的地址为:"<<p[0]<<endl<<endl;
            for (i=0;i<2;i++)
            {
                for (j=0;j<2;j++)
                    cout<<p[i][j]<<"\t";
                cout<<endl;
            }
            delete[] p;
            p=0;
            return 0;
    }

    转载于:https://www.cnblogs.com/audi-car/p/4442803.html

    展开全文
  • C++二维数组动态内存分配【转】

    千次阅读 2018-10-17 09:43:32
    (转自:... /*申请3行4列的二维数组内存*/ int **array; array = new int *[3];/*先申请3个int*类型的一维指针,作为行*/ for (i = 0; i < 3; i++) {/*再为每一行申请一个...
  • 写一个二维数组类 Array2,使得下面程序的输出结果是: 0,1,2,3, 4,5,6,7, 8,9,10,11, next 0,1,2,3, 4,5,6,7, 8,9,10,11, 程序: #include &lt;iostream&gt; #include &l...
  • 我要定义一个二维数组 a[N][2*N-1] N=1000000000; 我在VC+6.0 上只能定义到a[100][1000 我查阅资料,定义大数组需要动态分配内存使用mallo函数,我不知道怎么使用,最后怎么释放求代码! 计算机4G内存
  • 数组 现在可以解释为什么第1个程序第6行的输出为10的问题,根据结论1,数组名str的内涵为一种数据结构,即一个长度为10的char型数组,所以sizeof(str)的结果为这个数据结构占据的内存大小:10字节。 再看: 1. ...
  • 想问一下如果我的二维数组动态内存分配malloc函数放在了一个大的循环里面,free的时候只在循环外释放一次是不是会导致指针飞了,释放不完全。如果这样那应该怎么修改呢
  • 1.1前言 ...3.运行环境:由于在不同电脑配置和系统上的运行时间有差异,本程序的测试平台:电脑CPU为Intel奔腾双核E6500,主频2.93GHZ内存4GB.虚拟机为10.0版的VMware,linux系统为Fedora16 要讲程...
  • //为二维数据动态分配内存 for(int i=0;i;i++) { arr[i] = (int *)malloc(m*sizeof(int)); } for(int i = 0; i ; i ++) for(int j = 0; j ; j ++)//读取breast.txt,放在arr[20][20]中 fscanf(fp,"%d...
  • 今天我们来聊聊二维数组及其二维数组动态内存分配关知识。 1.数组的基本定义 我们都知道,数组是典型的线性存储,是一种最基本的存储表示方法, 把逻辑上相邻的元素存储在物理位置相邻的存储单元中,由此得到的...
  • C语言二维数组矩阵动态内存分配

    千次阅读 2014-07-30 22:29:06
    最近去参加面试,遇到二维数组矩阵动态内存分配,面试官当场叫我写个double类型的20*30的二维数组动态内存分配,当时就懵了,由于没有准备平时运用得比较少,结果没有写出来。。。。回来想想也并不是这么难,double...
  • 二维数组动态分配内存 C 二维数组动态分配和释放 (1)已知第二维 Code-1 char (*a)[N];//指向数组的指针 a = (char (*)[N])malloc(sizeof(char *) * m); printf("%d\n", sizeof(a));//4,指针 printf(&...
  • 一.一维数组 (一)一维数组定义格式 ...()一维数组的初始化 Java中的数组必须先初始化,然后才能使用 (1)初始化的分类: a:动态初始化: 只指定长度,由系统给出初始化值 b:静态初始化...
  • C/C++动态二维数组内存分配和释放

    千次阅读 2018-04-05 15:17:43
    原博客:http://www.cnblogs.com/Azhu/articles/3950487.htmlC语言//二维数组动态数组分配和释放 //数组指针的内存分配和释放 //方法一 char (*a)[N];//指向数组的指针 a = (char (*)[N])malloc(sizeof(char [N]...
  • 内存角度看,二维数组和一维数组一样,在内存中都是连续分布的多个内存单元,并没有本质差别,只是内存的管理方式不一样,如下图所示 一维数组int a[10]与二维数组int b[2][5]的对应关系 一维数组 a[0] a...
  • 指针数组、数组指针、二维数组动态分配内存 2016-03-22 22:59 838人阅读 评论(0) 收藏 举报  分类: C(7) C++(12)  目录(?)[+] 1. 二维数组动态分配和释放 1. 已知第...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 752
精华内容 300
关键字:

二维数组动态内存分配