精华内容
下载资源
问答
  • 维数组的首地址和数组名

    千次阅读 多人点赞 2019-05-25 09:15:15
    一维数组中,数组名表示是数组第一个元素的地址,那么二维数组呢? a表示是元素a[0][0]的地址?不是! 我们说过,二维数组就是一维数组 二维数组a[3][4]就有三个元素, 所以数组a第一个元素不是a[0][0],而是...

    二维数组a[M][N]的数组名 a 表示的是谁的地址?

    在一维数组中,数组名表示的是数组第一个元素的地址,那么二维数组呢?
    a表示的是元素a[0][0]的地址?不是!
    我们说过,二维数组就是一维数组
    二维数组a[3][4]就有三个元素,
    所以数组a的第一个元素不是a[0][0],而是a[0]的地址,
    即:

    a == &a[0];
    

    而a[0]又是a[0][0]的地址,即:

    a = &(&a[0][0])
    

    即二维数组名 a 就是地址的地址,必须两次取值才可以取出数组中存储的数据。对于二维数组a[M][N],数组名a 的类型为 int(*)[N],所以如果定义了一个指针变量 p:

    int *p;
    

    并希望这个指针变量指向二维数组 a,那么不能把 a 赋值给 p,因为他们的类型不一样,要么把 &a[0][0]赋值给 p,要么把 *a 赋值给 p,前两个好解释,可为什么可以把 *a赋值给 p呢?

    因为 a == &(&a[0][0]),所以 *a == *(&(&a[0][0])) == &[0][0]
    

    除此之外你可以把指针变量 p 定义为int(*)[N]型,这个时候就可以把 a 赋值给 p,而且用你这种方法的人比较多,但是我不太喜欢。

    如果将二维数组名 a 赋值给指针变量 p:则有:

    p = a;
    

    那么此时如何用 p 指向元素 a[i][j]?

    答案是以“行”为单位进行访问。
    数组名 a 代表第一个元素 a[0] 的地址,
    则 a + 1就代表元素 a[1] 的地址,即a + 1 == &a[1],
    a+2 就代表a[2]的地址 即 a + 2 == &a[2]

    以此类推,
    a + i == &a[i]

    因此就有:

    p + i == &a[i]
    *(p+i) = a[i]
    
    *(p+i) + j == a[i] + j;
    
    *(p+i) + j == &a[i][j];
    
    展开全文
  • 一维数组 定义一个数组:int a[5]; 此处,a,&a[0]以及&a做右值时在数值上是完全相同,但含义不同。 数组名a只能做右值,不能做左值。做右值是表示数组元素首的地址,同&a[0],如: ...

    一维数组

    定义一个数组:int a[5];

    此处,a,&a[0]以及&a做右值时在数值上是完全相同的,但含义不同。

    数组名a只能做右值,不能做左值。做右值是表示数组首元素首的地址,同&a[0],如:

    定义一个int *类型指针int * p,此时p=a和p=&a[0]完全是一个效果,一个意思。

    &a[0]即数组首元素首地址,只能做右值,同数组名a做右值。

    而&a,表示的则是整个数组的地址,其本身是一个常量,也只能做右值。

    注意a,&a[0]以及&a都是只能做右值的常量,且单纯从值这个角度看他们都是相等的,但含义千差万别,a和&a[0]是一样的,都表示int *类型的指针,而&a则表示为int *[5]的指针,即指向一个int型、含5个元素的数组的指针。

    含义的不同令其在参加指针运算时所表现的特征不同:

    *a和*(&a[0])一样,都表示第0个元素a[0],*(a+1)和*(&a[0]+1)一样,都表示a[1],它们每加1就表示加了sizeof(int)个字节;而(&a+1)则表示在数组a的地址的基础上加了sizeof(a)个字节数,即加了20个字节。此时访问*(&a+1)会出现数组越界的问题。

    ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

    二维数组

    定义一个二维数组:int a[2][3];

    表示定义了一个数组,数组名叫a,这个数组有两个元素a[0]和a[1],这两个元素均为一维数组,。

    其中a[0]是第一个一维数组的数组名(注意一定要将a[0]看做一维数组的数组名),这个一维数组有三个元素,分别为a[0][0]、a[0][1]、a[0][2]。

    a[1]是第二个一维数组的数组名(同样的一定要将a[1]看做一维数组的数组名),这个一维数组有三个元素,分别为a[1][0]、a[1][1]、a[1][2]。

    这样将二维数组拆成多个一维数组来理解,就可以将二维数组问题转化为一维数组问题,上面所讨论的关于一维数组的数组名、首元素、数组地址的结论均可应用到二维数组上来。

    首先,同一维数组一样,a,&a,a[0]和&a[0]在数值上是完全相等的,但含义不同。

    a是二维数组的数组名,是一个指针常量,只能做右值,不能做左值,做右值时表示数组首元素的首地址。这里数组的首元素是谁?没错是a[0],不用怀疑,只不过这个元素有点特殊,这个元素本身又是一个一维数组罢了。因此a和&a[0]是完全等价的。

    &a是整个二维数组的地址。

    现在来讨论指针指向二维数组数组名、数组元素的问题:

    1.指针指向二维数组的数组名:二维数组的数组名a做右值时相当于首元素a[0]的首地址(也就是数组名字为a[0]的数组的地址),而a[0]是一个一维数组的数组名,其本质为指向一维数组的指针,因此要指向二维数组的数组名,实质是需要定义一个指向一维数组的指针:int (*p1)[3] = a;

    上述定义也就相当于int (*p1)[3] =&a[0].这里p1是一个指向含三个int类型元素的一维数组,而a[0]正好是一个含三个int型元素的一维数组的数组名,对它取地址就表示含有三个int型元素的数组的地址,正好和二维数组名a的含义相同。

    2.指针指向二维数组的各个元素的数组名(二维数组当做一维数组看待时,其各元素为一维数组)

    这里的各个元素指的是把二维数组当成一维数组看待时的各个元素,此时a有两个元素,a[0]和a[1],分别为两个一维数组。a[0]和a[1]作为两个一维数组的数组名,表示的是一维数组的首元素的首地址。对于一维数组a[0],其首元素为a[0][0],是一个int型的变量,要想让指针指向其数组名,必须定义一个int型指针:int *p2 = a[0];

    上述定义也就相当于int *p2 = &a[0][0].这里p2是一个指向int型变量的指针,而而a[0]是一个一维数组的数组名,表示的是一维数组的首元素a[0][0](一个int型变量)的地址,可见p2和a[0]以及&a[0][0]的类型是匹配的。

    同理要定义一个指针指向二维数组的第二个元素(当做一维数组看待时)a[1],只需定义一个int型指针指向它即可:

    int * p3 = a[1];也即int *p3 = &a[1][0].

    3.指针指向二维数组

    这里的指向二维数组是指定义一个指针让其指向整个二维数组。

    注意和上面讲的指针指向二维数组的数组名相区别,二维数组的数组名表征的是二维数组首元素的地址,也就是其作为一维数组的各个元素中的第一个元素(是一个一维数组)的地址,说白了就是定义一个指向一维数组的指针。

    所以

    要定义一个指向二维数组的指针:int(*p4)[2][3] = &a;

    这里p4是一个执向二维数组的指针,指向一个什么样的二维数组呢?指向一个第一位大小为2,第二维大小为3的二维数组,也就是指向一个含有两个元素,每一个元素都是一个含3个有int型元素的数组的数组。

    好像有点绕,后面我再改改,精炼一下。。。。

    展开全文
  • 系统为每个数组元素分配等大的存储单元数组元素在内存中按照下标的先后顺序分配连续的存储单元按数组元素的类型不同,数组可分为数值数组、字符数组等数组可分为一维数组(向量)和二维数组(矩阵)★一维数组的定义类型...

    ★ 视频分享
    ★ 数组的概念    数组是相同数据类型的元素的集合。
    ★ 数组的特点
    • 一个数组中的所有元素具有相同的数据类型

    • 数组元素相当于变量,系统为每个数组元素分配等大的存储单元

    • 数组元素在内存中按照下标的先后顺序分配连续的存储单元

    • 按数组元素的类型不同,数组可分为数值数组、字符数组等

    • 数组可分为一维数组(向量)和二维数组(矩阵)


    ★ 一维数组的定义

    类型名 数组名[常量表达式];


    ★ 一维数组举例int a[10];
    • 定义了10个 int 型数组元素:a[0],a[1],……,a[9](没有a[10])

    • 系统为数组 a 开辟了 4*10 共 40 字节连续的存储单元

    • 数组名 a 表示数组的首地址(常量),即 a[0] 的地址

    • 定义数组时,[ ] 内必须是常量或常量表达式(不能是变量)

    • 引用数组元素时,[ ] 内可以是常量、变量或表达式


    ★ 一维数组举例

    T4_1:定义整型数组 a[10],输出每个数组元素 a[i] 的地址和数组 a 的首地址,以及数组 a 所占存储单元大小。

    4ecf81cf601a4a4aa33ac1fb550fb2da.png#include

    int main(void){    int a[10], i;         for (i=0; i<10; i++)    {        printf("&a[%d] = %d\n", i, &a[i]);    }         printf("a = %d\n", a);    printf("sizeof(a) = %d\n", sizeof(a));        return 0;}

    9d108cbc57c352e8d5a7d5dece0c1a31.png

    展开全文
  • 维数组的首地址、首行地址和元素地址

    千次阅读 多人点赞 2018-10-11 10:39:44
    a代表第0行的首地址,其步长为行的长度(16B), 所以a+1代表第1行的首地址,比a大16;a+2代表第2行的首地址,比a大32  printf("a=%d a+1=%d a+2=%d\n", a, a+1,a+2); &amp;a[...

    首先定义一个简单的三行四列的数组:

    int a[3][4] = { 1,2,3,4,5,6,7,8,9,10,11,12 };

     其中:

    a代表第0行的首地址,其步长为一行的长度(16B),

    所以a+1代表第1行的首地址,比a大16;a+2代表第2行的首地址,比a大32

     printf("a=%d  a+1=%d  a+2=%d\n", a, a+1,a+2);

    &a[i]代表第i行首地址,等价于a+i

    printf("&a[0]=%d  &a[1]=%d  &a[2]=%d\n\n", &a[0], &a[1], &a[2]);

    输出结果为:

     

    *a代表第0行第0个元素的地址,其步长为一个元素的长度(4B),所以*a+1比*a大4
    *(a+1)代表第1行第0个元素的地址,比*a大一行的长度(16)
    *(a+2)代表第2行第0个元素的地址,比*(a+1)大一行的长度(16)

    printf("*a=%d  *a+1=%d  *(a+1)=%d  *(a+2)=%d\n", *a, *a + 1, *(a + 1), *(a + 2));

    a[i]代表第i行首元素地址,等价于*(a+i)

    printf("a[0]=%d  \t\t a[1]=%d  a[2]=%d\n\n", a[0], a[1], a[2]);

    输出结果为:

     

    &a代表整个数组的首地址,其步长为一个数组的大小(48B)
    所以&a+1代表该数组最后一个元素的下个位置的地址,比a大48

    printf("&a=%d  &a+1=%d\n\n", &a, &a + 1);

    输出结果为:

    *(a+i)+j代表第i行第j列元素的地址
    *(a+0)+0代表第0行第0个元素,*a + 1代表第0行第1个元素,比*(a+0)+0大4
    *(a+1)+1代表第1行第1个元素,比*(a+0)+0大20(差5个元素)

    printf("*(a+0)+0=%d  *a+1=%d  *(a+1)+1=%d\n", *(a + 0) + 0, *a + 1, *(a + 1) + 1);

    &a[i][j]代表第i行第j列元素的地址,等价于*(a+i)+j

    printf("&a[0][0]=%d  &a[0][1]=%d  &a[1][1]=%d\n\n", &a[0][0], &a[0][1], &a[1][1]);

    输出结果为:

     

    &a与a与*a的值一样,但代表意义不同,实质是步长不同

    *(*(a+i)+j)比*(a+i)+j外面多个*,代表第i行第j列元素的值,等价于a[i][j]

    printf("*(*(a+0)+0)=%d  *(*(a+1)+1)=%d\n", *(*(a + 0) + 0), *(*(a + 1) + 1));

    printf("a[0][0]=%d  a[1][1]=%d\n", a[0][0], a[1][1]);

     输出结果为:

     

     

    展开全文
  • C编译程序用数组名存放数组在内存中的首地址。 指针访问内存比变量名访问... // a存放了数组的首地址 p=a; // 数组首地址赋给p p++; // 向下移动4个字节 指针与数组名都是地址,因此可以混合使用访问数组元素。...
  • 最近对标题所描述问题很疑惑,经过研究,可以分别求a和a+1的地址,通过地址差即可以...我结果是,一维数组名代表元素地址,二维数组名代表首行元素地址(一般情况下,首行元素地址等于该行元素地址)。 ...
  • 一维数组的首地址传给指针我们以这种形式书写:(p为指针) p=&a[0]; 或 p=a; 并且还可以用 p+n 与 a+n 的形式来替代表示a[n]。 二维数组与指针 但二维数组就发生了变化 将二维数组的首地址传给指针我们就应...
  • 一维数组的地址取值等于数组元素的地址。 2:二维数组: int a[2][2];*(*(a + i)+ j); a + i:第i+ 1个一维数组的地址。 *(a+i):第i+ 1个一维数组元素的地址。 *(a+ i)+ j:第i+1个一维数组...
  • c表示的是整个数组的首地址。 这三者的地址值是相同的,但第3与1、2含义却不一样,1与2不管是地址值还是含义都是一样的。 下面给出程序验证: 可以看到,c+1和&c[0]+1是以个char型大小为单位增加的,而&...
  • 一维数组中 a[i] 中的 a 代表了本数组的首地址,相当于 &a[0]。因此 *a 就等于 a[0]。那么对 a 加 1,就可以访问下一位:*(a+1) 就等于 a[1]。 访问一维数组首地址:a = &a[0]; 访问一维数组的元素:a[i] ...
  • 一维数组: int a[3]; &a是数组的地址,所以&a + 1是相当于增加12个...*(&a) = a:对一维数组的地址取值等于数组元素的地址。 一维数组名是指针常量,是元素的地址。 二维数组: int a[5][5]; *(*(a + i) + j)的解析
  • 假设数组的首地址为0x0, 则&a[2]则为0x2; 二维数组 形式为a[i][j],其中i表示行数,j表示列数,在内存中占用i * j个大小相等的连续空间,其中数组名a为该空间的首地址,类似于&a[0][0],a[1]为第1行的首...
  • C语言二维数组的指针及首地址问题

    千次阅读 2014-07-06 16:11:33
    同样的道理,arr是二维数组名时,*arr也是取arr的第一个元素,但是此时arr所指的元素是一个一维数组,所以,实际上arr所指元素是一维数组的首地址。 就按arr[3][4]这个例子来看:3行4列数组arr可以理解为arr[0],ar
  • 1、一位数组名:指针常量,保存数组首元素地址 &a:一位数组的地址 *(&a)=a; 对一位数组的地址取值等于数组...对二维数组的地址取值等于二维数组的首一维数组的地址 *aa=&aa[0][0]; *(*(aa+i...
  • 5 数组5.1 概述所谓数组,就是一个集合,里面存放了相同类型数据元素特点1:数组中每个==数据元素都是相同数据类型==特点2:数组是由==连续内存==位置组成5.2 一维数组5.2.1 一维数组定义方式一维数组定义...
  • 对于个二组数组int a[3][4],以下几个地址值是相等,但是地址类型不尽相同: 1)a 2)a[0] 3)*(a+0) 4)*a 5)&a[0][0] int a[3][4] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };printf("%x,%x,%...
  • 类比一维数组,一维数组的数组名为元素地址,数据类型为指针,到了二位数组,因为也将它看作是一维数组,那么它的数组名就是一个指向由二维数组第一行组成的数组的指针,叫做数组指针。而数组名+n,在一维数组中....
  • 一维数组与二维数组的区别

    千次阅读 2017-12-17 22:42:20
    一维数组与二维数组的区别:   int arr[10]  arr int* 指向一维数组首元素的地址 arr[0] int 第一个格子的值 arr+1 int* 指向一维数组第二个元素的地址,但是不会覆盖指向元素的指针 arr[0]+1 int...
  • 一维数组和二维数组

    2019-10-27 23:27:17
    一维数组 int arr[4]; arr: 指是数组首地址 arr+1 :地址+1 arr[0]: 首地址的值 arr[0]+1 :地址+1值 二维数组 int brr[3][4] 由于二维数组是以行行优先,所以将每行值“打包”成一个整体。 brr: 二维数组...
  • 一维数组 若有数组 int a[6]; a的值是数组元素的地址,所以a+1,就是第二个元素的地址。 而&a是整个数组的地址,所以&a+1,就是向后移动(10*4)个单位。所以相差40 一维数组方面较为基础,主要是记忆所以不...
  • a:整个数组的首地址,二级指针 a+1:跳4个字节 &a+1:跳12个字节 sizeof(a) :取的是整个数组长度12字节 sizeof(a[0]):取的是数组首元素,4字节 sizeof(&a):传的是一维数组整个数组的地址(首行地址),4个...
  • 一维数组与二维数组

    2018-02-13 11:15:46
    a表示这个二维数组的首地址 &a[0]表示的是这个二维数组第一维的首地址 &a[0][0]表示的是这个二维数组第一维第一个元素的地址。 这三个地址是相同的。 就好像一个班的位置,第一个位置,和第一排的第一个位置,...
  • 答: 是首地址,是数组的首地址,虽然值等于第一个元素的地址,但是不代表元素的地址. 1. 数组名都是地址常量,都是首地址,可以直接付给指针,但是一维数组和二维数组名 赋予指针时有点不一样. 2.数组名不是指针,它仅仅...
  • 数组表示 如上图所示,分别表示一维数组、二维数组位置... int *p,一维数组的数组默认指向数组的首地址,此时的首地址就是图中箭头所指的地方,数组中第一个元素的地址。 arr+1 ----> int *p, 一维数组arr ...
  • 今天要介绍的是一维数组与二维数组重一些常用的名称以及其类型,以供大家学习更易于...注意:只有一维数组的数组名才能被当作是数组元素的地址! 接下来便是二维数组,我们定义一个brr[3][4],然后再看两张图: ...
  • 编译器会把这里的 array 解析成指向整型元素的指针,也就是数组的首地址,方括号里面的数组编译器会忽略,写不写都可以,最好不写,以免引起误解。 void test(int array[]) {} 方法二:传指针 array是指向数组的...
  • array:一维数组的地址,同时也是一维数组元素的地址* array+i :一维数组第i+1个元素的地址 *array:一维数组元素的值 *(array+1):一维数组第i-1个元素的的值 *array+1:一维数组元素的值+1; in...
  • 指向一维数组的指针变量和指向二维...这个p一般指向的一维数组的首地址,即p=a,或者p=&a[0];p,a,&a[0]均指向同一单元,它们是数组a的首地址,也是0 号元素a[0]的首地址。p+1,a+1,&a[1]均指向1号元素a[1]。类推可知a+
  • 在a[N][N]中a[i]表示的第i行第列的地址 a+i表示的是第i行的首地址 a+i等同于&amp;a[i](所以a+1就是行移动,a[i]+1就是列移动) 

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,544
精华内容 617
关键字:

一维数组的首地址