精华内容
下载资源
问答
  • 问题:数组地址加1为啥可以到下一个元素? eg: int a[3]={1,2,3}; //定义一个数组 int*ptr_a=a; //定义一个指针并把数组的首地址(也就是数组名)给该指针 *(ptr_a+1); //这个式子的意思相当于 *(ptr_a+sizeof...

    问题:数组地址加1为啥可以到下一个元素?

    eg:

    int a[3]={1,2,3};  //定义一个数组

    int*ptr_a=a;        //定义一个指针并把数组的首地址(也就是数组名)给该指针

    *(ptr_a+1);         //这个式子的意思相当于   *(ptr_a+sizeof(int)*1),sizeof(int)指的的数组中每个元素所占据内存空间的大小,

                              int型占有4个字节,相邻的两个元素地址差4,所以加1即可到下一个元素,加2就到了下下个元素。

     

     

     


                                                 如果内容帮助到了你,麻烦给俺点个赞,让更多的追梦人受益!

                                                                   欢迎交流,共同学习,加油——追梦人!

    展开全文
  • 现在定义一个char a [10];的数组,下面对这几个名词...3、整个数组地址:就是整个数组的地址,取地址&a。 下面的代码进行测试: #include <stdio.h> #include <stdlib.h&g...

    现在定义一个char a [10];的数组,下面对这几个名词进行分析:

     

    1、数组首元素地址 :该数组有10个元素,数组首元素即a[0],取的是该元素的地址。

    2、数组首地址:就是数组名字a的地址。

    3、整个数组地址:就是整个数组的地址,取地址&a。

     

    下面的代码进行测试:

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    int main(void)
    {
    	char a[10];	//1 * 10 个字节
    
    	/*类型的本质:固定内存块大小别名
    	可以通过 sizeof()测试
    	*/
    
    	printf("sizeof(a) = %d\n", sizeof(a));
    
    
    	//打印地址
    	//数组名字,数组 首 元素地址,数组首地址
    	printf("a:%d, &a:%d &a[0]:%d\n", a, &a,&a[0]);
    
    
    	//a, &a的数据类型不一样
    	//a, 数组首元素地址, 一个元素1个字节,+1《==》 +1
    	//&a, 整个数组的首地址,一个数组1*10  = 10个字节,+1,《==》 +10
    	printf("a+1:%d, &a+1:%d  &a[1]:%d\n", a + 1, &a + 1, &a[1]);
    
    
    	printf("\n");
    	system("pause");
    	return 0;
    }

     

    测试结果:

     

    示意图:

              以上的测试结果说明,a 与&a的步长不一样,a代表的是数组首元素的地址,也是数组的首地址,加1等价于加一个数组类型的长度;&a代表的是整个数组的地址,加1等价于加整个数组的长度,此例子中也就是加10。

     

     

     

    展开全文
  • 关于指针与数组下标加1的问题

    千次阅读 2018-04-09 22:22:08
    我们在学习C语言的时候经常会碰到指针或者数组下标加1,这也是个令大家非常头疼的问题,那就是它加1以后实际上是加了多少,指针或者数组的下标移动到了哪里。 下面我就通过举几个例子来告诉大家答案。 例1: #...

    我们在学习C语言的时候经常会碰到指针或者数组下标加1,这也是个令大家非常头疼的问题,那就是它加1以后实际上是加了多少,指针或者数组的下标移动到了哪里。
    下面我就通过举几个例子来告诉大家答案。
    例1:

    #include <stdio.h>
    
    int main(int argc, char **argv)
    {
        int a[3]={
           0 
        };
        printf("%0x %0x %0x",a,a+1,&a+1);
    
    
    
    
        return 0;
    }
    

    打印结果:bfaf2268 bfaf226c bfaf2274
    我们定义了一个整型的一维数组,对于这个数组而言,加1相当于扫过一个int类型,即4个字节,也相当于元素后移一位,所以a与a+1的地址相差4,那么最后一个&a+1呢?
    我们知道a本身就是个地址,它是这个数组的首地址,那么我们取a的地址相当于取整个数组的地址,所以加1加的是整个数组,相当于往后移了整个数组,即4*3=12个字节。

    例2:

    #include <stdio.h>
    
    int main(int argc, char **argv)
    {
        int a[3][3]={1,2,3,4,5,6,7,8,9};
        printf("%0x %0x \n",a,a+1);
        printf("%0x %0x\n",a[0],a[0]+1);
        printf("%d\n",*(*(a+0)+1));
        printf("%0x\n",*(a+1));
        printf("%0x %0x %0x %0x\n",a+1,*(a+1),*(a+1)+1,&a[1][0]);
        int i,j;
        for(i=0;i<3;i++)
            for(j=0;j<3;j++)
                printf("%d  ",*(*(a+i)+j));
        printf("\n");
        return 0;
    }
    

    打印结果:
    bfcec434 bfcec440
    bfcec434 bfcec438
    2
    bfcec440
    bfcec440 bfcec440 bfcec444 bfcec440
    1 2 3 4 5 6 7 8 9
    我们首先定义了一个二维数组a,它和刚才的一维数组的区别就是a+1指的是数组移动了一行,也就是4*3=12个字节。为什么会这样呢?
    在二维数组a中,a和a[0]都是指针,都指向这个数组的第一个元素,但它们却有很大的区别:a是行指针,也就是说它指向的是行,对a加1移动的是一行。而a[0]是列指针,也就是说对a[0]加1只是往后移动了一个元素。
    其中a和&a[0]是等价的,当你对a[0]取地址后,它就从指向列指向了行。
    a[0]和&a[0][0]还有*(a+0)是等价的,它们都是指向列的。

    例3:

    #include <stdio.h>
    
    int main(int argc, char **argv)
    {
        int a[3][4]={{1,2,3,4},{3,4,5,6},{5,6,7,8}};
        int i;
        int (*p)[4]=a,*q=a[0];
        printf("%p %p\n",p,p+1);
        printf("%p %p\n",q,q+1);
        return 0;
    }
    

    打印结果:
    0xbff30698 0xbff306a8
    0xbff30680 0xbff30684

    我们定义了一个数组指针p,并且让这个数组指针p指向二维数组a,然后又定义了一个int型指针q指向a[0]。所谓数组指针就是这个指针指向的是一个数组的首地址,而且它不能指向一个一维数组,因为这样会和首元素的首地址相冲突。
    所以对于数组加1肯定是行加1,而a[0]是指向列的,所以a[0]+1只是列加1,。

    例4:

    #include <stdio.h>
    
    int main(int argc, char **argv)
    {
        char *p = "hello";
        printf("%p %p\n",p,p+1);
        printf("%p %p\n",*p,*p + 1);
        printf("%d\n",sizeof(p));
    
    
        return 0;
    }
    

    打印结果:
    0x80484e0 0x80484e1
    0x68 0x69
    4

    例5:

    #include <stdio.h>
    
    int main(int argc, char **argv)
    {
        int a = 4;
        int *p = &a;
        printf("%p %p\n",p,p+1);
        printf("%p %p\n",*p,*p + 1);
        printf("%d\n",sizeof(p));
    
        return 0;
    }
    

    打印结果:
    0xbfa7b9ec 0xbfa7b9f0
    0x4 0x5
    4

    由例4 例5这两个例子可以看出指针地址加1主要看你定义的指针所指向的类型。
    主要是看你定义指针的类型,比如你定义int *p=NULL; 那么int占4个字节。指向int的指针+1,该指针所指的内存地址要+4;如果你是定义 char *p=NULL; 那么char占1个字节。指向char的指针+1,该指针所指的内存地址只要+1。

    例6:

    #include <stdio.h>
    
    int main(int argc, char **argv)
    {
        int a[2][3]={1,2,3,4,5,6};
    
        int* *p;
        p=&a[0];
        printf("%p %p\n",*p,*p + 1);
        printf("% 0x %0x",p,p+1);
    
    
        return 0;
    }
    

    打印结果:
    0x1 0x5
    bfa2d998 bfa2d99c

    例:7:

     #include<stdio.h>
    int main()
    {
        char *name[]={"Follow me","BASIC","Great Wall","FORTRAN","Computer desighn"};
        char **p;
        p=name;
        printf("%0x %0x\n",p,p+1);
        printf("%0x %0x\n",name,name+1);
        printf("%p %p\n",*p,*p + 1);
        printf("%p %p\n",*name,*name + 1);
        return 0;
    }
    打印结果:
    bf8de058 bf8de05c
    bf8de048 bf8de04c
    0x8048583 0x8048584
    0x8048560 0x8048561
    
    由例67可以看出,如果定义的是二级指针p,那么我们二级指针加1,那么它的地址就是加4,因为它指向的类型是指针类型,所有的指针类型加1都是相当于加了4个字节。而*p就要看它指向的类型了,如果是int就是4个字节,如果是char就是1个字节。
    
    对于指针加1的问题确实比较抽象,难以理解,如果看了以后还有不懂的地方可以查阅相关的资料。
    
    
    展开全文
  • 数组名与数组名前地址

    千次阅读 多人点赞 2016-01-12 15:03:59
    我们知道数组名与数组名取地址所得到的地址都是一样的,由第一行的输出可以验证这一结论。那么如果都在这基础上加上指针运算呢,一开始我也觉得结果是相同的,但事实是让我懵逼的。由第二行输出可以知道a+1后指针

    代码:

    int main()

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

    cout<<a<<"\t"<<&a<<endl;
    cout<<a+1<<"\t"<<&a+1<<endl;
    return 0;

    }


    结果:



    我们知道数组名与数组名取地址所得到的地址都是一样的,由第一行的输出可以验证这一结论。那么如果都在这基础上加上指针运算呢,一开始我也觉得结果是相同的,但事实是让我懵逼的。由第二行输出可以知道a+1后指针指向的是组的第二个元素,而&a+1后指针指向的是整个数组内存空间的末尾。这是为什么呢?这到底是a的心灵的扭曲还是&a道德的沦丧?

    言归正传。。

    由于数组和指针的关系,a相当于一个指针,指向的是第一个元素,也就是传说中数组的首地址。此时这个指针的步长是数组元素类型所占的字节数,在此为4B。而&a这货代表的不是a这个变量的地址,而是数组元素的地址,它代表整个数组!!所以&a这个指针的步长是整个数组所占的字节数!!也就是说a的类型是int[10],&a的类型是int(*)[10],是个指向int[10]数组的指针,&a[0]的类型是int*。



    展开全文
  • c语言中,为什么在输出地址时,普通指针不用&,而数组地址&?
  • 此处a的类型看似为整个数组,实际上该数组名a为一个常量指针,也就是数组第一个元素a[0]的地址,同理a+1为第二个元素a[1]的地址。在上例中,数组名的类型就是指向int类型的常量指针,该值不可修改。 BUT! BUT! BUT!...
  • 程序实例:#include #include int main() ... //数组首元素地址 printf("&a[0]: %d\n", &a[0]); //数组首元素地址另一种获取方法 printf("&a[1]: %d\n", &a[1]); //数组第二个元素的地址 pri
  • 数组地址

    千次阅读 2019-05-31 20:34:20
    自己做了一下验证: ... cout (a + 1) ; // 00EFF908 cout (&a + 1) ; // 00EFF918 cout *(a + 1) ; // 2 cout *(&a + 1) ; // 00EFF918 vector<int> aa(a, a+5); system("pause"); return 0; }
  • 数组地址与整数的相加减(数组地址的偏移) 最终学习C/C++,遇到很多疑难杂症。希望用自己的理解和图形化的方式,把核心的问题表达清楚,即使是小白,也能看明白什么原理!(不忘初心,晚上鸡腿!) pa是指针...
  • 数组加1问题

    千次阅读 2018-07-14 11:42:25
    main() { int a[5]={1,2,3,4,5}; int *ptr=(int *)(&amp;a+1);...,*(a+1),*(ptr-1));...输出:2,5*(a+1)就是a[1],*...a+1不是首地址+1,系统会认为加一个a数组的偏移,是偏移了一个数组的大小(本例是5个int)i...
  • 数组指针加1操作的含义

    千次阅读 2015-12-13 19:26:26
    一般而言,对指针进行加1操作,得到的将是下一个元素的地址,一个类型为T的指针移动,是以sizeof(T)为移动单位。#include int main() { int a[5]={1,2,3,4,5}; int b[100]; int *ptr=(int*)(&a+1); //&a+1的单位...
  • 数组名和地址 先来看一个例子,然后通过分析例子来学习 #include <stdio.h> int a[3] = {1,2,3}; int main() { printf(" a = %p\n", a); // 1 printf(" &a = %p\n", &a); // 2 printf(" a + ...
  • 数组名前地址符&

    千次阅读 2019-07-07 22:27:05
    #include<iostream> using namespace std;... int a[4] = { 1,2,3,4 }; int* p = (int*)(&a + 1); //定义一个int型指针 cout << a << " " << (a+1)<<" "<&...
  • 数组地址计算解法集锦

    千次阅读 多人点赞 2018-07-04 20:14:02
    题目一:数组A中,每个元素的长度为3个字节,行下标i从1到8,列下标j从1到10,从首地址SA开始连续存放在存储器内,该数组按行存放时,元素A[8][5]的起始地址为()。 本题的数组是从A[1][1]开始的,也就是说和所谓...
  • 数组地址加一详解

    2021-01-29 10:03:01
    a+1相当于数组的一个单位(也就是一行),即&a[5] printf("%d", *(p-1)) //指针p-1相当于前移一个元素,输出为5 a是数组地址a[0]的地址,&a是对象(数组)首地址; a+1,表示指针指向下一个元素a[1...
  • @对字符数组输入输出数组名是否地址符的一些理解 定义了字符型数组,char name[20],name有两个含义,一个是代表着name这个数组第一个位置的地址,也就是name[0]的地址。可以说name就等价于&amp;amp;amp;...
  • 数组地址符的理解

    千次阅读 2019-04-15 15:00:58
     double data[100] , data有两个含义,一个是代表着data这个数组第一个位置的地址,也就是data[0]的地址。可以说data就等价于&data[0]。还有一种意思就是data整个数组。&data就是整个数组的首地址。所以data和&...
  • c++数组地址解析

    千次阅读 2016-09-15 12:59:58
    在c++语言中,一个二维数组可以有行地址和列地址,行地址和列地址之间可以相互转化。转化的规则是:在指向行地址的指针前面加一个*,就转化为指向列的指针。反之 在指向列地址的前面&,就成为指向行的指针!!!...
  • 数组名是元素首地址,所以一般都会认为: int a = {1,2,3,4}; for (int i=0;i<4;i++,a++)printf(“%d”,*a);//报错a++不允许减操作 为了让C编译器知道我们想让a自增或减,就得让C编译器知道这是指针类型的...
  • 数组地址问题

    2012-09-10 10:53:07
    通过下列来说明 main() { int a[5]={1,2,3,4,5};  int *ptr=(int *)(&a+1);... printf("%d,%d",*(a+1),*(ptr-1));...&a+1不是首地址+1,系统会认为加一个a数组的偏移,是偏移了一个数组的大小
  • #include void main() { struct student { int num; char name[20]; }; struct student sss[10]; struct student *p=sss; (*p).num=102;...p=sss+1; printf("%d\n",p);//增加了24个字节 p=p
  • 数组地址数组名取地址的区别

    千次阅读 2016-04-26 20:52:47
    数组地址数组名取地址的区别
  • 数组名与数组地址

    2010-03-17 23:42:00
    main(){int a[5]={1,2,3,4,5};...}输出:2,5*(a+1)就是a[1],*(ptr-1)就是a[4],执行结果是2,5&a+1不是首地址+1,系统会认为加一个a数组的偏移,是偏移了一个数组的大小(本例是5个int)int *ptr=(int *)(&a+1);
  • 以下C语言指令运行结果是? int a[5]={1,3,5,7,9}; int *p=(int *)(&a+1); printf("%d,%d",*(a+1),*(p-1));...a+1不是首地址+1,系统会认为了一个a数组,偏移了整个数组a的大小(也就是5个int的...
  • 关于数组地址问题

    2017-07-21 11:09:19
    c语言中“指针”是算是比较难的一个问题,而“指针”就是“地址”,知道数组地址问题,才能在用指针数组的时候得心应手。 下面是一段代码 #include <stdio.h>int main() { int a[3] = {1, 2, 3}; int b[2][3] = ...
  • 问题发现在int *p[4]和int (*ip)[4]的区别? 为了明白这个区分,做个小例子验证 以下是验证代码  int *p[4]; int a=0; int *q=NULL; p[0]= &a;...p[1]=q;...int arr[4]={1,2,3,4};...)不用地址
  • 数组运算

    千次阅读 2015-02-07 21:55:17
    16.若有定义:int aa[ 8];则以下表达式中不能代表数组元aa[1]的地址的是:___c__。 A) &aa[0]+1 B) &aa[1] C) &aa[0]++ D) aa+1  因为++是变量才能使用的,而&aa[0]是常量
  • c++数组名,数组地址和指针

    千次阅读 2019-03-29 20:28:35
    今天在牛客网上遇到一道神奇的题目: 下面代码的输出结果是? void main(void) ... printf("%d,%d",*(a+1),*(ptr-1)); } 这么一个大坑,我当然做错了,后来在vs上调试: void fun() { int a[5] = { ...
  • 数组地址

    2019-09-29 16:40:34
    指针可以,开始我们说了指针可以认为是游离的,所以他本身的值可以变化,而自就是让指针的首地址变化,但是数组是固定的, 要变化一个数组的首地址就要用到双指针。 关键:数组的首地址是常量指针 不能改变 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 335,615
精华内容 134,246
关键字:

数组怎么地址加1