精华内容
下载资源
问答
  • 二维数组动态分配内存 C 二维数组动态分配和释放 (1)已知第二维 Code-1 char (*a)[N];//指向数组的指针 a = (char (*)[N])malloc(sizeof(char *) * m); printf("%d\n", sizeof(a));//4,指针 printf(&...

    二维数组动态分配内存

    复制代码

    C 二维数组动态分配和释放
    (1)已知第二维
    Code-1
    char (*a)[N];//指向数组的指针
    a = (char (*)[N])malloc(sizeof(char *) * m);
    printf("%d\n", sizeof(a));//4,指针
    printf("%d\n", sizeof(a[0]));//N,一维数组
    free(a); 
    (2)已知第一维
    Code-2
    char* a[M];//指针的数组
    int i;
    for(i=0; i<M; i++)
    a[i] = (char *)malloc(sizeof(char) * n);
    printf("%d\n", sizeof(a));//4*M,指针数组
    printf("%d\n", sizeof(a[0]));//4,指针
    for(i=0; i<M; i++)
       free(a[i]); 
    (3)已知第一维,一次分配内存(保证内存的连续性)
    Code-3
    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;
    printf("%d\n", sizeof(a));//4*M,指针数组
    printf("%d\n", sizeof(a[0]));//4,指针
    free(a[0]); 
    (4)两维都未知
    Code-4
    char **a;
    int i;
    a = (char **)malloc(sizeof(char *) * m);//分配指针数组
    for(i=0; i<m; i++)
    {
    a[i] = (char *)malloc(sizeof(char) * n);//分配每个指针所指向的数组
    }
    printf("%d\n", sizeof(a));//4,指针
    printf("%d\n", sizeof(a[0]));//4,指针
    for(i=0; i<m; i++)
    {
    free(a[i]);
    }
    free(a); 
    (5)两维都未知,一次分配内存(保证内存的连续性)
    Code-5
    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;
    }
    printf("%d\n", sizeof(a));//4,指针
    printf("%d\n", sizeof(a[0]));//4,指针
    free(a[0]);
    free(a); 
    2.C++动态分配二维数组
    (1)已知第二维
    Code-6
    char (*a)[N];//指向数组的指针
    a = new char[m][N];
    printf("%d\n", sizeof(a));//4,指针
    printf("%d\n", sizeof(a[0]));//N,一维数组
    delete[] a; 
    (2)已知第一维
    Code-7
    char* a[M];//指针的数组
    for(int i=0; i<M; i++)
       a[i] = new char[n];
    printf("%d\n", sizeof(a));//4*M,指针数组
    printf("%d\n", sizeof(a[0]));//4,指针
    for(i=0; i<M; i++)
       delete[] a[i]; 
    (3)已知第一维,一次分配内存(保证内存的连续性)
    Code-8
    char* a[M];//指针的数组
    a[0] = new char[M*n];
    for(int i=1; i<M; i++)
    a[i] = a[i-1] + n;
    printf("%d\n", sizeof(a));//4*M,指针数组
    printf("%d\n", sizeof(a[0]));//4,指针
    delete[] a[0]; 
    (4)两维都未知
    Code-9
    char **a;
    a = new char* [m];//分配指针数组
    for(int i=0; i<m; i++)
    {
    a[i] = new char[n];//分配每个指针所指向的数组
    }
    printf("%d\n", sizeof(a));//4,指针
    printf("%d\n", sizeof(a[0]));//4,指针
    for(i=0; i<m; i++)
    delete[] a[i];
    delete[] a; 
    (5)两维都未知,一次分配内存(保证内存的连续性)
    Code-10
    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;//分配每个指针所指向的数组
    }
    printf("%d\n", sizeof(a));//4,指针
    printf("%d\n", sizeof(a[0]));//4,指针
    delete[] a[0];
    delete[] a; 
    多说一句:new和delete要注意配对使用,即有多少个new就有多少个delete,这样才可以避免内存泄漏!
    3.静态二维数组作为函数参数传递
    如果采用上述几种方法动态分配二维数组,那么将对应的数据类型作为函数参数就可以了。这里讨论静态二维数组作为函数参数传递,即按照以下的调用方式:
    int a[2][3];
    func(a);
    C语言中将静态二维数组作为参数传递比较麻烦,一般需要指明第二维的长度,如果不给定第二维长度,则只能先将其作为一维指针传递,然后利用二维数组的线性存储特性,在函数体内转化为对指定元素的访问。
    首先写好测试代码,以验证参数传递的正确性:
    (1)给定第二维长度
    Code-11
    void func(int a[][N])
    {
    printf("%d\n", a[1][2]);
    } 
    (2)不给定第二维长度
    Code-12
    void func(int* a)
    {
    printf("%d\n", a[1 * N + 2]);//计算元素位置
    } 
    注意:使用该函数时需要将二维数组首地址强制转换为一维指针,即func((int*)a);
    展开全文
  • 指针数组、数组指针、二维数组动态分配内存 2016-03-22 22:59 838人阅读 评论(0) 收藏 举报  分类: C(7) C++(12)  目录(?)[+] 1. 二维数组动态分配和释放 1. 已知第...

    指针数组、数组指针、二维数组动态分配内存

     838人阅读 评论(0) 收藏 举报
     分类:
     

    目录(?)[+]

    1. 二维数组动态分配和释放

    1. 已知第二维

    char (*a)[N];//指向数组的指针
    a = (char (*)[N])malloc(sizeof(char *) * m);
    printf("%d\n", sizeof(a));//4,指针
    printf("%d\n", sizeof(a[0]));//N,一维数组
    free(a); 
    • 1
    • 2
    • 3
    • 4
    • 5
    • 1
    • 2
    • 3
    • 4
    • 5

    2. 已知第一维

    char* a[M];//指针的数组
    int i;
    for(i=0; i<M; i++)
    a[i] = (char *)malloc(sizeof(char) * n);
    printf("%d\n", sizeof(a));//4*M,指针数组
    printf("%d\n", sizeof(a[0]));//4,指针
    for(i=0; i<M; i++)
       free(a[i]); 
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    3.已知第一维,一次分配内存(保证内存的连续性)

    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;
    printf("%d\n", sizeof(a));//4*M,指针数组
    printf("%d\n", sizeof(a[0]));//4,指针
    free(a[0]); 
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    4.两维都未知

    char **a;
    int i;
    a = (char **)malloc(sizeof(char *) * m);//分配指针数组
    for(i=0; i <m; i++)
    {
    a[i] = (char *)malloc(sizeof(char) * n);//分配每个指针所指向的数组
    }
    printf("%d\n", sizeof(a));//4,指针
    printf("%d\n", sizeof(a[0]));//4,指针
    for(i=0; i<m; i++)
    {
    free(a[i]);
    }
    free(a); 
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    5.两维都未知,一次分配内存(保证内存的连续性)

    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;
    }
    printf("%d\n", sizeof(a));//4,指针
    printf("%d\n", sizeof(a[0]));//4,指针
    free(a[0]);
    free(a); 
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    2.C++动态分配二维数组

    1.已知第二维

    char (*a)[N];//指向数组的指针
    a = new char[m][N];
    printf("%d\n", sizeof(a));//4,指针
    printf("%d\n", sizeof(a[0]));//N,一维数组
    delete[] a; 
    • 1
    • 2
    • 3
    • 4
    • 5
    • 1
    • 2
    • 3
    • 4
    • 5

    2.已知第一维

    char* a[M];//指针的数组
    for(int i=0; i<M; i++)
       a[i] = new char[n];
    printf("%d\n", sizeof(a));//4*M,指针数组
    printf("%d\n", sizeof(a[0]));//4,指针
    for(i=0; i<M; i++)
       delete[] a[i]; 
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    3.已知第一维,一次分配内存(保证内存的连续性)

    char* a[M];//指针的数组
    a[0] = new char[M*n];
    for(int i=1; i<M; i++)
    a[i] = a[i-1] + n;
    printf("%d\n", sizeof(a));//4*M,指针数组
    printf("%d\n", sizeof(a[0]));//4,指针
    delete[] a[0]; 
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    4.两维都未知

    char **a;
    a = new char* [m];//分配指针数组
    for(int i=0; i<m; i++)
    {
    a[i] = new char[n];//分配每个指针所指向的数组
    }
    printf("%d\n", sizeof(a));//4,指针
    printf("%d\n", sizeof(a[0]));//4,指针
    for(i=0; i<m; i++)
    delete[] a[i];
    delete[] a; 
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    5.两维都未知,一次分配内存(保证内存的连续性)

    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;//分配每个指针所指向的数组
    }
    printf("%d\n", sizeof(a));//4,指针
    printf("%d\n", sizeof(a[0]));//4,指针
    delete[] a[0];
    delete[] a; 
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

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

    3.静态二维数组作为函数参数传递

    如果采用上述几种方法动态分配二维数组,那么将对应的数据类型作为函数参数就可以了。这里讨论静态二维数组作为函数参数传递,即按照以下的调用方式:

       int a[2][3];
       func(a);
    • 1
    • 2
    • 1
    • 2

    C语言中将静态二维数组作为参数传递比较麻烦,一般需要指明第二维的长度,如果不给定第二维长度,则只能先将其作为一维指针传递,然后利用二维数组的线性存储特性,在函数体内转化为对指定元素的访问。 
    首先写好测试代码,以验证参数传递的正确性:

    1.给定第二维长度

    void func(int a[][N])
    {
        printf("%d\n", a[1][2]);
    } 
    • 1
    • 2
    • 3
    • 4
    • 1
    • 2
    • 3
    • 4

    2.不给定第二维长度

    void func(int* a)
    {
        printf("%d\n", a[1 * N + 2]);//计算元素位置
    } 
    • 1
    • 2
    • 3
    • 4
    • 1
    • 2
    • 3
    • 4

    注意:使用该函数时需要将二维数组首地址强制转换为一维指针,即func((int*)a);

    展开全文
  • C语言为二维数组动态分配内存的问题

    万次阅读 多人点赞 2013-09-07 22:57:22
    C语言中动态分配一位数组是很简单的,但是没有可以直接对二维数组进行动态分配的函数,因此,要相对二维数组动态分配内存,便要借助于一位数组来实现,具体如下:   假设要为一个n*m的二维数组分配动态内存   首先...

    转载请注明出处:http://blog.csdn.net/ns_code/article/details/11357667


    C语言中动态分配一位数组是很简单的,但是没有可以直接对二维数组进行动态分配的函数,因此,要相对二维数组动态分配内存,便要借助于一位数组来实现,具体如下:

     

    假设要为一个n*m的二维数组分配动态内存

     

    首先需要注意的是,不要这样一次性分配为数组内存空间:

    int **arr = (int**)malloc(n * m * sizeof(int));

    正确的做法是先分配行,再分配列。

    释放内存的时候,要先释放列,再释放行。

    注意,顺序反了的话,会把列的地址擦除,导致释放列时内存时找不到地址,程序崩溃。

    正确的分配空间代码如下:

     int **arr = (int **)malloc(n*sizeof(int *));
     for(i=0;i<n;i++)
         arr[i] = (int *)malloc(m*sizeof(int));

     

    正确的释放空间代码如下:

     for (i = 0; i < n; i++)
         free(arr[i]);
    /
    *释放列*/

     free(arr);/*释放行*/


    注:这种分配方式得到的其实并不是真正意义上的二维数组,因为其行与行之间的内存并不连续,虽然可以用下标arr[i][j]的方式访问,但当用指向该二维数组的指针来访问时候,不能通过指针值的增加来跨行获取元素,不过这种情况一般用的也不多,因此上述分配方式在大多数情况下的操作都能得到正确的结果。

    一篇文章分析的不错,源地址:http://tsindahui.blog.sohu.com/84512010.html

    展开全文
  • C语言中二维数组动态分配内存

    万次阅读 2013-09-01 13:01:49
    最近《数据结构》看到哈夫曼树的构造一部分的...这就涉及到二维数组内存的动态分配问题,先来看如何给一个普通的4行5列二维数组分配内存。 [code=c] int **p; int i; if( NULL == (p = (int **)malloc(4 * sizeof(in

    最近《数据结构》看到哈夫曼树的构造一部分的程序,构造程序使用了锯齿状数组——即一种特殊二维数组,只不过每一行的长度是根据需要存放的元素个数分配的。这就涉及到二维数组内存的动态分配问题,先来看如何给一个普通的4行5列二维数组分配内存。

    int **p;
    int i;
    
    
    if( NULL == (p = (int **)malloc(4 * sizeof(int *))) )
         return -1;
    
    
    for(i = 0; i < 4; i++)
    {
         if( NULL == (p[i] = (int *)malloc(5 * sizeof(int))) )
             return -1;
    }
            
    for(i = 0; i < 4; i++)
    {
         free(p[i]);
    }
    free(p);
    

     


    在C语言中二维数组其实是数组的数组。第5行给p分配了4个都为指向int的指针大小的内存空间(对应着二维数组的行),然后第11行分别给每行都分配5个int大小的内存空间,这些内存空间在内存中都是线性排列的。
    编译器在处理如上代码时,并不是真的就给每行分配5个int大小的内存空间,在gcc 4.7.2-2中,通常会多分配一个int大小的内存空间(如下图所示)。而在VC6.0中会多分配14个。

     

     

     

    gcc为如上代码中二维数组的内存分配情况如下图:

    后来不小心在程序中写了类似与p[2][50] = 7;的代码,这段代码明显数组越界了,但编译器没有报错。一直在纠结为啥会这样,如果你看了上面那副图你就知道了,其实这时p[2][50]虽然从你分配的内存空间中"越界",此时它用的是图中最后的空白区域的某一块内存,而C语言对数组不会进行越界检查,所以编译器并没有报错。

    展开全文
  • //动态分配 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; ...
  • // 输出10 } 接下来看对定义方式为double **a的如何用malloc对其动态分配内存: 1)方法1: #include #include #include using namespace std; int main(){ int row=20, colum=10; double **a; /* 为a分配row个指针...
  • 首先,我们一般需要用到数组的时候,都是直接声明,比如: 1 int array[3][3];  但是,在某些情况下,数组的维数我们是不知道的,可能是等待用户输入维数,这时候需要用变量来...我们一步一步来,申请一维数组
  • =10)的二维矩阵,计算其周围一圈元素之和。 (提示:可以用循环累加第一行最后一行第一列最后一列,再减去矩阵四个角的元素,注意数组下标从0开始) 输入数据只有一组,首先在第一行输入n,接下来有n行,每行输入n个...
  • C++动态数组分配 int **arr; int m, n;//非连续分配 arr = new int*[m]; for(int i = 0; i ; i ++) arr[i] = new int[n];//连续分配内存 arr = new int*[m]; arr[0] = new int[m * n]; for(int i = 1; i
  • 今天最算法project时遇到需要使用一个动态数组,并且这个数组在编译时还是不知道大小的,到底能不能给二维数组动态分配空间,我还真没试过。是不是跟一维数组一样?用int *ar = new int[n][m],试了一下不行。 后来...

空空如也

空空如也

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

二维数组动态分配内存