动态分配二维数组

最新推荐文章于 2020-01-31 18:42:15 发布
最新推荐文章于 2020-01-31 18:42:15 发布
阅读量514 收藏 1
点赞数 1
分类专栏： C语言的一些坑 文章标签： 二维数组 指针
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014717036/article/details/51470988
版权

为二维数组动态分配内存涉及以下两个问题：

  • 数组元素是否需要连续
  • 数组是否规则

在这里我们暂时不考虑数组是否规则，我们从数组元素的分配是否连续考虑。

已知第二维

    // 数组指针
    char (*a1)[COLUMNS];
    a1 = (char(*)[COLUMNS])calloc(ROWS,sizeof(char*));

已知第一维

    // 指针数组
    char *a2[ROWS];
    for(int i = 0; i < ROWS; i++) {
        a2[i] = (char*)calloc(COLUMNS, sizeof(char));
    }

已知第一维，一次分配内存（保证内存分配的连续性）

    // 指针数组
    char *a3[ROWS];
    a3[0] = (char *)calloc(ROWS*COLUMNS, sizeof(char));
    for(int i = 1; i < ROWS; i++) {
        a3[i] = a3[i-1] + COLUMNS;
    }

两维都未知

    // 二级指针
    char **a4;
    a4 = (char **)calloc(ROWS, sizeof(char*));
    for(int i = 0; i < ROWS; i++) {
        a4[i] = (char*)calloc(COLUMNS, sizeof(char));
    }

两维都未知，一次分配内存（保证内存分配的连续性）

    // 二级指针
    char **a5;
    a5 = (char**)calloc(ROWS, sizeof(char*));
    a5[0] = (char*)calloc(ROWS*COLUMNS, sizeof(char));
    for(int i = 1; i < ROWS; i++) {
        a5[i] = a5[i-1] + COLUMNS;
    }

完整代码

/*
 * 二维数组的动态内存分配
 * 测试指针和数组之间的关系
 */

#include <stdio.h>
#include <stdlib.h>

#define ROWS 6
#define COLUMNS 5

#define P(a) \
        { \
            printf("sizeof(%s):\t%d\n",#a, (sizeof((a)))); \
            printf("sizeof(%s[0]):\t%d\n",#a,(sizeof((a)[0]))); \
        }

#define OUT(a) \
        {        \
         printf("%s:\t  addr:%p\n",(#a),(a)); \
         for(int i = 0; i < ROWS; i++){ \
            printf("%s[%d]:\t  addr:%p\n",#a,i,((a)[i])); \
         } \
         for(int i = 0; i < ROWS; i++){ \
            for(int j = 0; j < COLUMNS; j++){ \
                printf("%s[%d][%d]: addr:%p\t",(#a),i,j,&a[i][j]);\
            } \
            printf("\n"); \
         } \
        }

// 打印数组的地址信息
#define INFO(a) \
        { \
         P(a) \
         OUT(a) \
        }

int main(int argc, char *argv[])
{
    printf("-----二维数组-----\n");
    printf("a[%d][%d]\n",ROWS,COLUMNS);
    // #1 已知第二维
    // 数组指针
    char (*a1)[COLUMNS];
    a1 = (char(*)[COLUMNS])calloc(ROWS,sizeof(char*));
    printf("*****数组指针*****\n");
    INFO(a1)

    // #2 已知第一维
    // 指针数组
    char *a2[ROWS];
    for(int i = 0; i < ROWS; i++) {
        a2[i] = (char*)calloc(COLUMNS, sizeof(char));
    }
    printf("*****指针数组*****\n");
    INFO(a2)

    // #3 已知第一维，一次分配内存（保证内存分配的连续性）
    // 指针数组
    char *a3[ROWS];
    a3[0] = (char *)calloc(ROWS*COLUMNS, sizeof(char));
    for(int i = 1; i < ROWS; i++) {
        a3[i] = a3[i-1] + COLUMNS;
    }
    printf("*****指针数组，一次分配内存*****\n");
    INFO(a3)

    // #4 两维都未知
    // 二级指针
    char **a4;
    a4 = (char **)calloc(ROWS, sizeof(char*));
    for(int i = 0; i < ROWS; i++) {
        a4[i] = (char*)calloc(COLUMNS, sizeof(char));
    }
    printf("*****两维都未知*****\n");
    INFO(a4)

    // #5 两维都未知，一次分配内存（保证内存分配的连续性）
    // 二级指针
    char **a5;
    a5 = (char**)calloc(ROWS, sizeof(char*));
    a5[0] = (char*)calloc(ROWS*COLUMNS, sizeof(char));
    for(int i = 1; i < ROWS; i++) {
        a5[i] = a5[i-1] + COLUMNS;
    }
    printf("*****两维都未知，一次分配内存*****\n");
    INFO(a5)

    // 统一释放申请的内存空间
    // free a1
    free(a1);
    // free a2
    for(int i = 0; i < ROWS; i++) {
        free(a2[i]);
    }
    // free a3
    free(a3[0]);
    // free a4
    for(int i = 0; i < ROWS; i++) {
        free(a4[i]);
    }
    free(a4);
    // free a5
    free(a5[0]);
    free(a5);
    return 0;
}

输出结果

-----二维数组-----
a[6][5]
*****数组指针*****
sizeof(a1): 4
sizeof(a1[0]):  5
a1:       addr:0x9bb2008
a1[0]:    addr:0x9bb2008
a1[1]:    addr:0x9bb200d
a1[2]:    addr:0x9bb2012
a1[3]:    addr:0x9bb2017
a1[4]:    addr:0x9bb201c
a1[5]:    addr:0x9bb2021
a1[0][0]: addr:0x9bb2008    a1[0][1]: addr:0x9bb2009    a1[0][2]: addr:0x9bb200a    a1[0][3]: addr:0x9bb200b    a1[0][4]: addr:0x9bb200c    
a1[1][0]: addr:0x9bb200d    a1[1][1]: addr:0x9bb200e    a1[1][2]: addr:0x9bb200f    a1[1][3]: addr:0x9bb2010    a1[1][4]: addr:0x9bb2011    
a1[2][0]: addr:0x9bb2012    a1[2][1]: addr:0x9bb2013    a1[2][2]: addr:0x9bb2014    a1[2][3]: addr:0x9bb2015    a1[2][4]: addr:0x9bb2016    
a1[3][0]: addr:0x9bb2017    a1[3][1]: addr:0x9bb2018    a1[3][2]: addr:0x9bb2019    a1[3][3]: addr:0x9bb201a    a1[3][4]: addr:0x9bb201b    
a1[4][0]: addr:0x9bb201c    a1[4][1]: addr:0x9bb201d    a1[4][2]: addr:0x9bb201e    a1[4][3]: addr:0x9bb201f    a1[4][4]: addr:0x9bb2020    
a1[5][0]: addr:0x9bb2021    a1[5][1]: addr:0x9bb2022    a1[5][2]: addr:0x9bb2023    a1[5][3]: addr:0x9bb2024    a1[5][4]: addr:0x9bb2025    
*****指针数组*****
sizeof(a2): 24
sizeof(a2[0]):  4
a2:       addr:0xbfbbbc60
a2[0]:    addr:0x9bb2028
a2[1]:    addr:0x9bb2038
a2[2]:    addr:0x9bb2048
a2[3]:    addr:0x9bb2058
a2[4]:    addr:0x9bb2068
a2[5]:    addr:0x9bb2078
a2[0][0]: addr:0x9bb2028    a2[0][1]: addr:0x9bb2029    a2[0][2]: addr:0x9bb202a    a2[0][3]: addr:0x9bb202b    a2[0][4]: addr:0x9bb202c    
a2[1][0]: addr:0x9bb2038    a2[1][1]: addr:0x9bb2039    a2[1][2]: addr:0x9bb203a    a2[1][3]: addr:0x9bb203b    a2[1][4]: addr:0x9bb203c    
a2[2][0]: addr:0x9bb2048    a2[2][1]: addr:0x9bb2049    a2[2][2]: addr:0x9bb204a    a2[2][3]: addr:0x9bb204b    a2[2][4]: addr:0x9bb204c    
a2[3][0]: addr:0x9bb2058    a2[3][1]: addr:0x9bb2059    a2[3][2]: addr:0x9bb205a    a2[3][3]: addr:0x9bb205b    a2[3][4]: addr:0x9bb205c    
a2[4][0]: addr:0x9bb2068    a2[4][1]: addr:0x9bb2069    a2[4][2]: addr:0x9bb206a    a2[4][3]: addr:0x9bb206b    a2[4][4]: addr:0x9bb206c    
a2[5][0]: addr:0x9bb2078    a2[5][1]: addr:0x9bb2079    a2[5][2]: addr:0x9bb207a    a2[5][3]: addr:0x9bb207b    a2[5][4]: addr:0x9bb207c    
*****指针数组，一次分配内存*****
sizeof(a3): 24
sizeof(a3[0]):  4
a3:       addr:0xbfbbbc78
a3[0]:    addr:0x9bb2088
a3[1]:    addr:0x9bb208d
a3[2]:    addr:0x9bb2092
a3[3]:    addr:0x9bb2097
a3[4]:    addr:0x9bb209c
a3[5]:    addr:0x9bb20a1
a3[0][0]: addr:0x9bb2088    a3[0][1]: addr:0x9bb2089    a3[0][2]: addr:0x9bb208a    a3[0][3]: addr:0x9bb208b    a3[0][4]: addr:0x9bb208c    
a3[1][0]: addr:0x9bb208d    a3[1][1]: addr:0x9bb208e    a3[1][2]: addr:0x9bb208f    a3[1][3]: addr:0x9bb2090    a3[1][4]: addr:0x9bb2091    
a3[2][0]: addr:0x9bb2092    a3[2][1]: addr:0x9bb2093    a3[2][2]: addr:0x9bb2094    a3[2][3]: addr:0x9bb2095    a3[2][4]: addr:0x9bb2096    
a3[3][0]: addr:0x9bb2097    a3[3][1]: addr:0x9bb2098    a3[3][2]: addr:0x9bb2099    a3[3][3]: addr:0x9bb209a    a3[3][4]: addr:0x9bb209b    
a3[4][0]: addr:0x9bb209c    a3[4][1]: addr:0x9bb209d    a3[4][2]: addr:0x9bb209e    a3[4][3]: addr:0x9bb209f    a3[4][4]: addr:0x9bb20a0    
a3[5][0]: addr:0x9bb20a1    a3[5][1]: addr:0x9bb20a2    a3[5][2]: addr:0x9bb20a3    a3[5][3]: addr:0x9bb20a4    a3[5][4]: addr:0x9bb20a5    
*****两维都未知*****
sizeof(a4): 4
sizeof(a4[0]):  4
a4:       addr:0x9bb20b0
a4[0]:    addr:0x9bb20d0
a4[1]:    addr:0x9bb20e0
a4[2]:    addr:0x9bb20f0
a4[3]:    addr:0x9bb2100
a4[4]:    addr:0x9bb2110
a4[5]:    addr:0x9bb2120
a4[0][0]: addr:0x9bb20d0    a4[0][1]: addr:0x9bb20d1    a4[0][2]: addr:0x9bb20d2    a4[0][3]: addr:0x9bb20d3    a4[0][4]: addr:0x9bb20d4    
a4[1][0]: addr:0x9bb20e0    a4[1][1]: addr:0x9bb20e1    a4[1][2]: addr:0x9bb20e2    a4[1][3]: addr:0x9bb20e3    a4[1][4]: addr:0x9bb20e4    
a4[2][0]: addr:0x9bb20f0    a4[2][1]: addr:0x9bb20f1    a4[2][2]: addr:0x9bb20f2    a4[2][3]: addr:0x9bb20f3    a4[2][4]: addr:0x9bb20f4    
a4[3][0]: addr:0x9bb2100    a4[3][1]: addr:0x9bb2101    a4[3][2]: addr:0x9bb2102    a4[3][3]: addr:0x9bb2103    a4[3][4]: addr:0x9bb2104    
a4[4][0]: addr:0x9bb2110    a4[4][1]: addr:0x9bb2111    a4[4][2]: addr:0x9bb2112    a4[4][3]: addr:0x9bb2113    a4[4][4]: addr:0x9bb2114    
a4[5][0]: addr:0x9bb2120    a4[5][1]: addr:0x9bb2121    a4[5][2]: addr:0x9bb2122    a4[5][3]: addr:0x9bb2123    a4[5][4]: addr:0x9bb2124    
*****两维都未知，一次分配内存*****
sizeof(a5): 4
sizeof(a5[0]):  4
a5:       addr:0x9bb2130
a5[0]:    addr:0x9bb2150
a5[1]:    addr:0x9bb2155
a5[2]:    addr:0x9bb215a
a5[3]:    addr:0x9bb215f
a5[4]:    addr:0x9bb2164
a5[5]:    addr:0x9bb2169
a5[0][0]: addr:0x9bb2150    a5[0][1]: addr:0x9bb2151    a5[0][2]: addr:0x9bb2152    a5[0][3]: addr:0x9bb2153    a5[0][4]: addr:0x9bb2154    
a5[1][0]: addr:0x9bb2155    a5[1][1]: addr:0x9bb2156    a5[1][2]: addr:0x9bb2157    a5[1][3]: addr:0x9bb2158    a5[1][4]: addr:0x9bb2159    
a5[2][0]: addr:0x9bb215a    a5[2][1]: addr:0x9bb215b    a5[2][2]: addr:0x9bb215c    a5[2][3]: addr:0x9bb215d    a5[2][4]: addr:0x9bb215e    
a5[3][0]: addr:0x9bb215f    a5[3][1]: addr:0x9bb2160    a5[3][2]: addr:0x9bb2161    a5[3][3]: addr:0x9bb2162    a5[3][4]: addr:0x9bb2163    
a5[4][0]: addr:0x9bb2164    a5[4][1]: addr:0x9bb2165    a5[4][2]: addr:0x9bb2166    a5[4][3]: addr:0x9bb2167    a5[4][4]: addr:0x9bb2168    
a5[5][0]: addr:0x9bb2169    a5[5][1]: addr:0x9bb216a    a5[5][2]: addr:0x9bb216b    a5[5][3]: addr:0x9bb216c    a5[5][4]: addr:0x9bb216d

参考

unauthorized401
关注
专栏目录
c语言二维数组如何动态赋值,如何在C中动态分配二维数组
weixin_42468245的博客
05-23 2201
在C语言中如何动态申请连续的二维数组。可以采用多申请一些指针，然后这一些指针分别指向后面数据区中对应的位置，如一个3*4的int类型数组，我们先申请大小为sizeof(int*) * 3 + 3 * 4 * sizeof(int)的一维数组设为arr。然后arr[0]存放指向arr + sizeof(int*) * 3这个位置的指针，arr[1]存放指向arr + sizeof(int*) * 3...
二维数组动态分配方法
hello world
10-19 2955
二维数组动态分配方法 C语言中对于二维数组可以只定义列而不定义行，当我们想要定义行和列时，如想定义p3可以用如下方法： int **p;//int*p是指向int的指针，int**p是指向一级指针的指针 p = (int**p)malloc(sizeof(int*)*4);//malloc动态分配内存定义行 for(int i = 0;i<4;i++) { p[i] = (int *)malloc(sizeof(int)*3)//定义列 } 可按以下图示理解（十二个位子全部存放的是int*型的指针）：
二维数组的动态分配
brave
09-28 2104
一维数组分配比较简单，在此略过。但是平时经常遇到需要动态分配二维数组的情况。下面给出几种二维数组分配方式。 注：二维数组行坐标、列坐标都是通过m,n来传递的。 1. 利用一维数组分配方式，模拟二维数组 其实栈上二维数组仍然是个连续的内存空间，只不过在访问时做了相应的处理。那么，动态分配时，也可分配一块连续的内存空间。访问时通过(d + i m + j )访问即可。 in
C++二维数组的动态分配
01-20
C++中动态分配一维数组是十分常见的事，但会分配一维数组的人并不一定会分配二维数组。因为我想，不到特殊情况，我们可能很少想过要使用动态分配的二维数组。但不管怎么样，只要你是第一次想试着去分配一个二维数组...
C语言中动态分配二维数组.doc
10-03
C语言中动态分配二维数组 在 C 语言中动态分配二维数组是一种常见的操作，但是在 C 语言书中，关于动态分配二维数组的方法却鲜有提及。在这里，我们将讨论两种方法来动态分配二维数组，并分析它们的优缺。 方法一...
C与C++动态分配二维数组的实现方法
08-31
在C和C++编程语言中，动态分配内存是常见的...总之，C和C++提供不同的方法来动态分配二维数组，但都需要谨慎处理内存分配和释放，以避免内存泄漏和其他潜在问题。了解这些基本概念是成为一名熟练的C/C++程序员的关键。
C语言动态分配二维数组
04-06
本文将详细介绍如何在C语言中动态分配二维数组，并通过具体的代码示例来解释这一过程。 ### C语言动态分配二维数组 #### 标题解读： 标题“C语言动态分配二维数组”直接指出了本文的主要内容是关于在C语言环境下...
二维数组的动态分配和删除
热门推荐
jia_xiaoxin的专栏
11-10 1万+
二维数组的动态分配和删除  首先，动态支持数组的分配，必须用   new   来进行创建一段堆内存，其它的存贮区域不允许动态分配的产生。     其次，C++并没有提供真正的动态多维数组语法，想动态分配数组，必须通过一维动态数组组合形成一个类似多维数组的存贮形式，并不像静态分配多维数组，它们的用法虽说有些地方　有相似之处，但不完全相同。     再次，有些网友有一些很BT的分配方式。    
二维数组及其动态内存分配
baymaxly的博客
01-31 1万+
一、二维数组的基本概念 1.1 二维数组的内存映像 从内存角度看，二维数组和一维数组一样，在内存中都是连续分布的多个内存单元，并没有本质差别，只是内存的管理方式不一样，如下图所示 一维数组int a[10]与二维数组int b[2][5]的对应关系 一维数组 a[0] a[1] a[4] a[5] a[9] 二维数组 b[0][0] b[0][1] b[0][4] b[1...
二维数组及其二维数组的动态内存分配
Kevinonlie的博客
03-14 6758
本文为大一时所写的文章（2017/4/9），文笔还很生疏，在很多问题上认识不深，算是在学校的微信公众号上的一个编程探究模块上的投稿，本人当时也参与了本模块的维护和管理。补档。 今天我们来聊聊二维数组及其二维数组的动态内存分配关知识。 1.数组的基本定义 我们都知道，数组是典型的线性存储，是一种最基本的存储表示方法， 把逻辑上相邻的元素存储在物理位置相邻的存储单元中，由此得到的存储表示称为线性存储结...
如何动态分配二维数组
最新发布
08-30
在大多数编程语言中，动态分配二维数组通常涉及到两层指针操作。以下是在C++和Java中动态创建二维数组的例子： **C++示例**: ```cpp int rows, cols; cout ; cin >> rows >> cols; // 创建动态二维数组 (std::...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值