精华内容
下载资源
问答
  • C语言_数组_二维数组的定义和二维数组元素引用
    千次阅读
    2020-09-14 18:02:54

    通过赋初值定义二维数组的大小

     

    第一种:

    例如:int a[][3] = {{1, 2, 3}, {4, 5}, {6}, {8}};

    注意:

           对于二维数组,省略只能省略第一个方括号中的常量表达式

    如上的初赋值语句等同于:

           int a[4][3] = {{1, 2, 3}, {4, 5}, {6}, {8}};

     

     

    第二种:int = c[][3] = {1, 2, 3, 4, 5};

           要计算第一个空的方括号中的值x:

         当花括号对中的个数能整除第二维的常量表达式时,整数的结果就是第一维的大小;否则,第一维的大小等于所得的结果加1。

    (即5/3 = 1 ……2, x = 1 +1 =2)

     

     

    二维数组和指针

    例如:int *p, a[3][4];

           //定义p为指针变量,a是含有12个元素的一维数组

    二维数组实际是一个一维数组,而每一个元素又是一个一维数组。

    如上述a,有三个元素a[0],a[1],a[2];而每个元素又是由四个整数元素组成的一维数组。

    通过a[0][0],a[0][1]引用,可以把a[0]看做一个整体,当做一个数组名。

    a[0]就是代表a[0][0]的地址。

    p = a[0]是合法的        p = a[0]+1 相当于&a[0][1]

     

    从基类型来看,a为具有4个整型元素的数组类型。

           注意:p = a;        //非法    p基类型只有4个字节,a基类型有4*4个字节

     

     

    二维数组取地址

           有变量i和j,它们的取值范围为0 <= I < 3 、0 <= j < 4

    那么a[i][j]的地址可以用以下五种表达形式:

    (1)&a[i][j]

    (2)a[i]+j

    (3)*(a+i)+j

    (4)&a[0][0]+4*i+j

    (5)a[0]+4*i+j

    更多相关内容
  • 我定义了这样一个数组,我想把这个数组作为参数,传递到一个函数中,并要在函数中能引用二维数组元素,我该怎么做?  第一种方式是直接传递二维数组,但是必须标明第二维的值,因为如果只是传递a[][],编译器...
  • 指针 二维数组元素引用

    千次阅读 2020-12-30 16:30:24
    二维数组元素指针引用 指针与一维数组和二维数组 1.定义 2.关系 3.数组指针和指针数组的区别 数组指针(也称行指针) 定义 int (*p)[n]; ()优先级高,首先说明p是一个指针,指向一个整型的一维数组,这个一维数组的...

    二维数组元素指针引用

    1.定义
    2.数组指针和指针数组的区别

    1.二维数组可以理解为是一个一维数组,不过每个数组元素又是一个一维数组
    int a[2][3]={{1,2,3},{4,5,6}};
    可以理解为,二维数组只有两个元素,即a[0]和a[1],只不过元素类型为一维数组
    指向二维数组的指针(行指针)
    格式:类型 (*指针名) [N]
    N为数组的第二维长度

    2.二维数组指针与指针型数组的区别

    int a[][3] = { {1,2,3},{4,5,6} };

    int *p0[3] = a;    //错误,将一个二维数组赋给指针型数组
    
    int(*p1)[3] = a;   //正确
    

    数组指针(也称行指针)
    定义 int (*p)[n];
    ()优先级高,首先说明p是一个指针,指向一个整型的一维数组,这个一维数组的长度是n,也可以说是p的步长。也就是说执行p+1时,p要跨过n个整型数据的长度。

    如要将**二维数组**赋给一指针,应这样赋值:
    int a[3][4];
    int (*p)[4]; //该语句是定义一个数组指针,指向含4个元素的一维数组。
     p=a;        //将该二维数组的首地址赋给p,也就是a[0]或&a[0][0]
     p++;       //该语句执行过后,也就是p=p+1;p跨过行a[0][]指向了行a[1][  ]
    

    比如要表示数组中i行j列一个元素:

    *(p[i]+j)*(*(p+i)+j)(*(p+i))[j]、p[i][j]
    

    优先级:()>[]>*
    出处:
    https://www.cnblogs.com/hongcha717/archive/2010/10/24/1859780.html

    3.实现一个3*4阶矩阵转置 指针为形参

    #define _CRT_SECURE_NO_WARNINGS
    #include <stdio.h>
    #include<stdlib.h>
    //定义一个3行4列的二维数组arr。
    //定义一个函数func()完成矩阵转置,以数组指针作为参数。
    //在func()函数内部,使用for循环完成矩阵转置
    void func(int(*pa)[4], int(*pb)[3], int x, int y)
    {
        int i, j;
        /*-------------------------begin------------------*/
        for(i=0;i<x;i++)
           for(j=0;j<y;j++){      	
           	 *(pb[j]+i)=*(pa[i]+j);
           	 // *(*(pb+j)+i)=*(*(pa+i)+j);
           	 // pb[j][i]=pa[i][j];
           	 // (*(pb+j))[i]=(*(pa+i))[j];
    	   }
        /*--------------------------end-------------------*/
        printf("转置:\n");
        for (i = 0; i < y; i++)
        {
            for (j = 0; j < x; j++)
            {
                printf("%d\t", pb[i][j]);
            }
            printf("\n");
        }
    }
    int main()
    {
        int i, j;
        int arr[3][4], brr[4][3];
        printf("输入二维数组的元素:\n");
        for (i = 0; i < 3; i++)
        {
            for (j = 0; j < 4; j++)
            {
                scanf("%d", &arr[i][j]);
            }
        }
        func(arr,brr,3,4);
        return 0;
    }
    
    
    
    

    在这里插入图片描述
    另有:

    数组元素访问 方法总结

    展开全文
  • 一、二维数组元素由其行、列下标决定 以float a[3][4];为例: 1.引用a[2][3]—行、列下标均是整数 2.引用a[2-1][2*2-1]—行、列下标可以是整型表达式 3.a[1][2]=3.14/2;—数组元素作为赋值表达式的左值 4.a[3][4]=15...

    一、二维数组元素由其行、列下标决定

    以float a[3][4];为例:

    1.引用a[2][3] — 行、列下标均是整数

    2.引用a[2-1][2*2-1] — 行、列下标可以是整型表达式

    3.a[1][2]=3.14/2; — 数组元素作为赋值表达式的左值

    4.a[3][4]=15; — 错误!最后一个元素是a[2][3],“越界”

    二、输入输出二维数组元素

    1.二维数组行序优先输出

    #include <stdio.h>
    int main()
    {
    	int a[3][5]; //定义3行5列的二维数组
    	int i; //循环中用于记录行数变化
    	int j; //循环中用于记录列数变化
    	
    	//嵌套循环方式输入数组元素
    	for (i = 0; i < 3; ++i) 
    	{
    		for (j = 0; j < 5; ++j)
    		{
    			scanf_s("%d", &a[i][j]);
    		}
    	}
    	//嵌套循环方式输出数组元素:常规操作
    	for (i = 0; i < 3; ++i)
    	{
    		for (j = 0; j < 5; ++j)
    		{
    			printf("%d\t", a[i][j]);
    		}
    		putchar('\n');
    	}
    }
    运行结果:
    85 78 99 96 88
    76 89 75 97 74
    64 92 90 73 56
    85      78      99      96      88
    76      89      75      97      74
    64      92      90      73      56
    

    2.二维数组列序优先输出

    #include <stdio.h>
    int main()
    {
    	int a[3][5];
    	int i;
    	int j;
    	for (i = 0; i < 3; ++i)
    	{
    		for (j = 0; j < 5; ++j)
    		{
    			scanf_s("%d", &a[i][j]);
    		}
    	}
    	//循环嵌套方式输出数组元素:列序优先
    	for (i = 0; i < 5; ++i)
    	{
    		for (j = 0; j < 3; ++j)
    		{
    			printf("%d\t", a[j][i]); //注意i,j顺序
    		}
    		putchar('\n');
    	}
    }
    运行结果:
    85 78 99 96 88
    76 89 75 97 74
    64 92 90 73 56
    85      76      64
    78      89      92
    99      75      90
    96      97      73
    88      74      56
    

    3.二维数组元素倒序输出

    #include <stdio.h>
    int main()
    {
    	int a[3][5];
    	int i;
    	int j;
    	for (i = 0; i < 3; ++i)
    	{
    		for (j = 0; j < 5; ++j)
    		{
    			scanf_s("%d", &a[i][j]);
    		}
    	}
    	for (i = 2; i >=0; --i)
    	{
    		for (j = 4; j >=0; --j)
    		{
    			printf("%d\t", a[i][j]);
    		}
    		putchar('\n');
    	}
    }
    运行结果:
    85 78 99 96 88
    76 89 75 97 74
    64 92 90 73 56
    56      73      90      92      64
    74      97      75      89      76
    88      96      99      78      85
    

    三、实例:二维数组行列互换后存入另一个二维数组

    #include <stdio.h>
    int main()
    {
    	int a[2][3] ={{1,2,3},{4,5,6}};
    	int b[3][2];
    	int i;
    	int j;
    	printf("array a: \n");
    	for (i = 0; i < 2; ++i)
    	{
    		for (j = 0; j < 3; ++j)
    		{
    			printf("%d\t", a[i][j]);
    		}
    		putchar('\n');
    	}
    	for (i = 0; i < 2; ++i)
    	{
    		for (j = 0; j < 3; ++j)
    		{
    			b[j][i] = a[i][j];
    		}
    	}
    	printf("array b: \n");
    	for (i = 0; i < 3; ++i)
    	{
    		for (j = 0; j < 2; ++j)
    		{
    			printf("%d\t", b[i][j]);
    		}
    		putchar('\n');
    	}
    }
    运行结果:
    array a:
    1       2       3
    4       5       6
    array b:
    1       4
    2       5
    3       6
    
    展开全文
  • C++中指针指向二维数组实例详解 一维指针通常用指针表示,其指向的地址是数组第一元素所在的内存地址,如下 int ary[4][5]; int(*aryp)[5] = ary; 那么ary[4]相当于int(*aryp),以下理解如此,但参数传递需要知道...
  • C语言二维数组及指针引用

    千次阅读 2022-04-11 15:40:58
    用指针引用二维数组元素 C语言二维数组及指针引用 1.二维数组的定义与表示 二维数组是形如: 表示一个int类型,三行四列的数组 int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12} 表示一个char类型,两行三列的数组 char s...

    C语言二维数组及指针引用

    1.二维数组的定义与表示

    二维数组是形如:

    表示一个int类型,三行四列的数组
    int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12}
    
    表示一个char类型,两行三列的数组
    char s[2][3]={{'a','b','c'},{'d','e','f'}}
    

    二维数组a的存储形式如下表所示:

    行 / 列 行/列 /a[i][0]a[i][1]a[i][2]a[i][3]
    a[0]1234
    a[1]5678
    a[2]9101112
    a[3]13141516

    其中a[i][j]则表示第i+1行中的第j+1个数
    例如:
    a[2][3]则表示第3行第4个数:12
    a[0][1]则表示第1行第2个数:2

    注意,二维数组名s表示的是一个地址常量,同时s可以看作一个二级指针常量,即:

    ss[0]s[1]s[2]s[3]
    s[0]s[0][1]s[0][1]s[0][2]s[0][3]

    注意,数组名都是首地址常量,s可以看作是一个一维数组的首地址,这个数组中存了4个元素,分别为s[0],s[1],s[2],s[3]这四个数组名,没错这四个元素可以单独看作是四个数组的数组名。比如s[0]则记录了s[0]那一行数组的首地址。
    而以s[0]的值为首地址的数组中又存放了s[0][0],s[0][1],s[0][2],s[0][3]这4个元素。

    也就是说,s这个一维数组s[0]s[1]s[2]s[3]中存放的不是具体的元素数值,而是4个一维数组的首地址:s[0],s[1],s[2],s[3],而每一个以s[i]为首地址的数组中存放的才是具体的数值s[i][j]

    2.用指针引用二维数组元素

    我们先从一个问题的引入进行分析:
    对于字符数组s考虑下面两种指针的引用形式:
    第一种:

    char *p=(char *)s;
    

    这行代码的意义是,将二维数组s的首地址转换成字符指针的类型并赋值给字符指针p,这样一来,指针p指向的就是二维数组s的首元素地址,p+1的操作可以让p每次向后移动一个字符char元素的位置。

    第二种:

    char (*p)[3]=s;
    

    首先理解char (p)[3]的含义:这是一个指针,指向的类型是一个大小为3的一维数组。那么p的值就是数组名的地址,数组名也是地址,所以这是一个指向地址的指针,什么意思呢,意思就是这个指针p中存的是地址的地址,所以是二级指针。那么 * p的意义是取p指向的数组首地址,而 ** p的意义才是数组中第一个元素。

    两种形式指针对二维数组的引用都行得通:

    • 第一种简单笨拙,每次移动一个元素去引用对应的二维数组中的第n个元素。
    • 第二种在明白其意义后则很方便直接指向第几行第几列的元素。

    考虑完这两种指针的意义后,我们分别对上面两种情形执行下面的程序:
    第一种:

    char s[2][3]={'a','b','c','d','e','f'};
    char *p=(char*)s;
    printf("%c",*++p+2);
    

    运行结果如下:

    打印出字符:d
    

    解释:数组名s原本是一个二级地址,但是通过强制类型转换(char *)将其转换为了一个一级地址,可以理解为将原来有层次的存储空间进行了扁平化处理,平铺成了一个很长的连续的一维数组,然后通过移动p去引用,那么我们看 ++p+2的意义,++优先级最高,所以指针p向后移动一个元素指向b,其次的优先级高,*p取出了p指向的元素b,b+2的ascII码为字符d

    第二种:

    char s[2][3]={'a','b','c','d','e','f'};
    char (*p)[3]=s;
    printf("%c",*(*++p+2));
    

    运行结果如下:

    打印出字符:f
    

    解释:char (p)[3]=s;的意义上面已经详细说过了,p指向的是s为首的一维数组中的第一个数组s[0],s[0]是一个一行三列的一维数组,p存放了s[0]的地址。++p的操作让p向后移动一个单元,指向了s[1],然后执行的p操作取出来s[1]的值,s[1]的值是第二列一维数组的首地址,也就是元素d的地址,然后再对*p+2的操作让这个首地址向后移动了两个单元指向了元素f,值为f的地址。最后对其进行 * 操作取出地址对应的值,则结果是元素f

    展开全文
  • 二维数组元素引用

    千次阅读 2020-03-04 11:21:17
    下面代码中,三种引用 ```cpp #include <iostream> using namespace std; int main() { int b = 0; int a[3][4] = { {1,2,3,6},{2,5,6,76},{6,4,7,3} }; for (int i = 0; i < 3; i++) for (int j = 0...
  • C语言:二维数组元素引用

    千次阅读 2017-09-12 17:34:08
    任务代码: (1) #include int main() { int a[3][5],i,j; printf("输入3*5数组:\n"); //输入 for(i=0;i;i++) { for(j=0;j;j++) { scanf("%d",&a[i][j]); }
  • C语言二维数组的定义和引用C语言二维数组的定义和引用7.1.1二维数组的定义前面介绍的数组只有一个下标,称为一维数组,其数组元素也称为单下标变量。在实际问题中有很多量是二维的或多维的,因此C语言允许构造多维...
  • 欢迎下载 C 语言程序设计课程教案表 授课题目 课时安排 2 第四章 数组2二维数组 授课时间 教学目的和要求 1掌握二维数组的定义与使用方法 教学内容 1基本内容1二维数组的定义和使用方法 2 重点二维数组引用 ...
  • 本文实例讲述了javascript二维数组和对象的深拷贝与浅拷贝。分享给大家供大家参考,具体如下: 这篇文章主要为大家详细介绍了js实现数组和对象的深浅拷贝, 1.浅拷贝: 将原对象或原数组的引用直接赋给新对象,新...
  • 二维数组引用总结

    千次阅读 2017-07-13 13:29:15
    今天在论坛上有朋友提问:声明函数如下void function(int** pInt),意图是想参数传递一个二维数组。于是就定义了一个二维数组,比如 int[1][1],然后调用函数。结果如何?当然是失败了,编译器提示:cannot ...
  • 即若干个字符变量的集合,数组中的每个元素都是字符型的变量 char 组名[]; 2)短整型的数组 short int 组名[]; 3)整型的数组 int 组名[]; 4)长整型的数组 long int 组名[]; 5)浮点型的数组(单、双) float ...
  • C语言定义和引用二维数组

    千次阅读 2021-01-08 18:13:48
    怎样定义和引用二维数组 二维数组常称为矩阵。把二维数组写成行(row)和列(column)的排列形式,可以有助于形象地理解二维数组的逻辑结构。 一.怎样定义二维数组 其基本概念与方法与一维数组相似,如: float pay[3]...
  • 如果&数组名放在里面就是求指针大小 二维数组中,数组名是首元素地址,二维数组的首元素是第一行的地址,它解引用就是第一行第一个元素的地址,再解引用一次就是第一行第一个元素的值。 我们再用一维数组仔细解释...
  • C语言总结第七章、数组一维数组一维数组的定义一维数组的引用一维数组的初始化程序举例二维数组及多维数组二维数组的定义二维数组元素引用二维数组元素的初始化程序举例字符数组和字符串字符数组 第七章、数组 ...
  • 从前面的讨论中,我们不难得出一个推论,*a即数组a中下标为0的元素引用。例如,我们可以这样写: *a=84;  这个语句将数组a中下标...  现在我们可以考虑二维数组了,正如前面所讨论的,它实际上是以数组为元素
  • #include&lt;iostream&gt;using namespace std;#include&lt;stdlib.h&gt;void main(){ int a[10] = { 1,2,3,4,5,6,7,8,9,...//一维数组引用 int i = 1; for (auto data : ra) { data += i; //i+...
  • 目录一维数组创建一维数组给一维数组赋值获取数组的长度常见错误二维数组创建二维数组二维数组赋值二维数组的使用场景多维数组不规则数组数组的基本操作遍历数组填充和批量替换数组元素难点解答为什么数组索引从0...
  • Matlab中数组元素引用——三种方法

    千次阅读 2021-04-21 13:47:45
    1.Matlab中数组元素引用有三种方法1.下标法(subscripts)2.索引法(index)3.布尔法(Boolean)注意:在使用这三种方法之前,大家头脑一定要清晰的记住,Matlab中数组元素是按列存储(与Fortran一样),比如说下面的二维...
  • 怎样定义和引用二维数组

    千次阅读 2019-11-20 11:24:45
    二维数组元素的存放:连续存放,存放第0行,然后再存放第1行 2,引用 数组名【行标】【列标】 行标从0开始,到行数减一 列标从0开始,到列标减一 二维数组的遍历,通常采用双重for循环,外层控制行,内层控制列 3...
  • 设置我正在用python编写一个类来处理一个二维的布尔数组。在class Grid(object):def __init__(self, length):self.length = lengthself.grid = [[False]*length for i in range(length)]def coordinates(self, index...
  • 【C语言】二维数组

    多人点赞 热门讨论 2021-11-27 20:10:21
    前面的博客介绍了一维数组只有一个下标,称为一维数组,其数组元素也称为单下标变量。我们在实际问题当中很多量是由二维或者是多维的,因此 C 语言允许构造了多维数组。...本片文章介绍的是二维数组
  • 维数组元素默认初始化值的情况分为两种,元素为基本数据类型和引用数据类型 1. 元素为基本数据类型时  1. 整型类型(byte、short、int、long) 默认的初始值都为0  2. 浮点类型(float、double) 默认的初始值...
  • 需要在程序中使用二维数组,网上找到一种这样的用法:#创建一个宽度为3,高度为4的数组#[[0,0,0],# [0,0,0],# [0,0,0],# [0,0,0]]myList = [[0] * 3] * 4但是当操作myList[0][1] = 1时,发现整个第二列都被赋值,...
  • C++一维数组定义一维数组定义一维数组的一般格式为:类型标识符 数组名[常量表达式];例如:int a[10];它表示数组名为a,此数组为整型,有10个元素。关于一维数组的几点说明:1) 数组名定名规则和变量名相同,遵循...
  • java二维数组创建方法

    2021-04-23 13:39:01
    java动态创建二维数组,从零学java笔录-第31篇 图解二位数组在内存中存储,java二维数组动态赋值,java二维数组创建方法二维数组的定义 type arrayName[ ][ ]; type [ ][ ]arrayName Java 二维数组的声明、初始化和引用...
  • 一维数组与二维数组

    2021-07-05 19:54:16
    2.二维数组的声明的两种方式:3.二维数组创建的三种方式4.二维数组的迭代 1.一维数组 1.什么是数组? 数组是相同数据类型元素的集合。 简单说,数组即就是在计算机内存中找一块连续的内存,在里面放相同类型的数据...
  • 二维数组怎么理解

    2021-06-12 12:53:26
    二维数组可以看成是以一维数组为元素的一维数组。通常将最外层的一维数组称为外维数组;而作为元素的内层数组称为内维数组。如下: //声明一个字符串类型的二维数组,其中外维数组的长度为3,内维数组的长度为2。 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 79,904
精华内容 31,961
关键字:

对二维数组元素的引用方法