精华内容
下载资源
问答
  • 我们知道一维数组常量指针,我们可以将一维数组名赋给一个指针类型再对一维数组进行相关的操作,那二维数组名又什么?我们这样初始化一个二维数组int A[3][3]={1,2,3,4,5,6,7,8}或者为int A[3][3]={ {1,2,3},{...

    我们知道一维数组名是常量指针,我们可以将一维数组名赋给一个指针类型再对一维数组进行相关的操作,那二维数组名又是什么? 
    我们这样初始化一个二维数组int A[3][3]={1,2,3,4,5,6,7,8}或者为int A[3][3]={ {1,2,3},{4,5,6},{7,8,9}};从后面一个定义我们可以看出二维数组是由两个一维数组组成的也就是说二维数组是“数组的数组”。 
    问题 
    了解了二维数组那么二维数组名又是什么呢,是不是和一维数组名一样是个一维指针呢?看下面代码:

    1 #include<stdio.h>
    2  void main()
    3  { int i,j;
    4    int A[3][3]={{0,1,2},{3,4,5},{6,7,8}};
    5    printf("%x\n",A);
    6    printf("%x\n",*A);
    7    printf("%d\n",**A);
    8 
    9  }

    从代码的结果可以看出只有**A才能输出数组中的元素,*A输出的是一个地址,那么我们是不是可以吧二维数组名理解为指针的指针。然后定义一个指针的指针 int **p,将数组名赋给p然后二维数组进行相关操作呢?答案是否定的,看下面代码: 
    代码1

    1 #include<stdio.h>
    2  void main()
    3  { int i,j;
    4    int A[3][3]={{0,1,2},{3,4,5},{6,7,8}};
    5    int **p;
    6    p=A;
    7    printf("%d",**p);
    8 
    9  }

    但是这个代码编译不过,显示error为“无法从int[3][3]转化为int **,那就说明了二维数组名不是指针的指针。那二维数组名又是什么呢?看代码: 
    代码2

     1 #include<stdio.h>
     2  void main()
     3  { int i,j;
     4    int A[3][3]={{0,1,2},{3,4,5},{6,7,8}};
     5    int (*p)[3];
     6    p=A;
     7    for(i=0;i<3;i++)
     8   { for(j=0;j<3;j++)
     9     printf("%2d",*(*(p+i)+j));
    10     printf("\n");
    11      }
    12 
    13  }

    从这个结果我们可以看出我们可以先定义一个数组指针int (*p)[3],然后将A数组名然后进行相关操作,即二维数组名是一个数组指针,然后对P+1指向的是下一个数组即下一行的地址进行操作。 
    原因 
    二维数组名即数组地址,指向首行地址,不是指针的指针。表面上看,行地址即一维数组指针,而数组名指向行搜索就应该是指针的指针。 但是你考虑过没有,如果A[3][3],假设int**p=A; 那么要对行递增执行p++时,编译器如何知道列宽?因为int**是指指向一个 int 类型的指针,其数据宽度是4字节,内置宽度,因此p将指向下一个整数元素地址,也就是p递增了4字节,而不是3个int型数据的宽度,这就错位了。 所以A[3][3]的地址类型不是简单的指针的指针,而是行指针的指针,而行宽是由你定义的数组列数和元素类型所决定,int类型就是4*3=12个字节。这叫数据对齐。因此编译器在转换数组名时,会根据对齐要求而确定相应的指针类型,所以A的地址类型应该是int ()[3],而不是int **。 所以应该这样int (*p)[3]=A; 其含义为,p是一个指向(含3个int类型元素的一维数组或行的)指针,其实本质上任何指针都是4字节(32位系统),你完全可以将一种指针类型强制转为任何其他类型,那为什么还要区分指针类型,就是为了指针运算时实现数据对齐,准确定位。

    转自:http://m.blog.csdn.net/toyalll/article/details/50043193

    转载于:https://www.cnblogs.com/CZT-TS/p/7654901.html

    展开全文
  • 指针变量也是变量,所以const关键字自然也可以用来修饰指针。 const修饰指针常见的有4种形式,区分清楚这4种即可全部理解const和指针。以int类型指针为例: 第一种:const int *p;,表示p本身不是const,*p是const...

    1.深入学习数组

    1.1 从内存角度来理解数组

    从内存角度讲,数组变量就是一次分配多个同类型的变量,并且这些变量在内存中的存储单元是连续依次分布的。

    分开定义多个变量,比如int a, b, c, d;和一次定义一个数组int a[4];,这两种定义方法相同点是都定义了4个int型变量,而且这4个变量都是独立的单个使用的。不同点是单独定义时abcd在内存中的地址不一定相连,但是定义成数组后,数组中的4个元素地址肯定是连续依次相连的。

    数组中多个变量虽然必须单独访问,但是因为它们的地址是连续分布的,因此很适合用指针来操作,于是数组和指针之间的关系就叫天生纠结在一起的。

    1.2 从编译器角度来理解数组

    从编译器角度来讲,数组变量也是变量,和普通变量和指针变量并没有本质区别。变量的本质就是一个有地址编号的内存空间,这个地址由编译器决定具体数值,具体数值和变量名绑定,变量类型决定这个地址的延续长度。

    1.3 数组中几个关键符号的理解

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

    aa[0]&a&a[0]这4个符号搞清楚了,数组相关的很多问题都有答案了。理解这些符号的时候要和左值右值结合起来,也就是搞清楚每个符号分别做左值和右值时的不同含义。

    • a就是数组名。a做左值时表示整个数组的所有空间:5×4=20字节,又因为C语言规定数组操作时要每个元素独立单个操作,不能整体操作数组,所以a不能做左值。a做右值表示数组首元素,也就是a[0]的首地址,首地址就是起始地址,就是4个字节中最开始第一个字节的地址,a做右值等同于&a[0];
    • a[0]表示数组的首元素,也就是数组的第0个元素。a[0]做左值时表示数组第0个元素对应的连续4字节内存空间。做右值时表示数组第0个元素的值,也就是数组第0个元素对应的内存空间中存储的那个数。
    • &a就是数组名a取地址,字面意思来看就应该是数组的地址。&a不能做左值,因为&a实质是一个常量而不是变量因此不能赋值,所以自然不能做左值。&a做右值时表示整个数组的首地址。
    • &a[0]字面意思就是数组第0个元素的首地址,[]的优先级要高于&,所以a先和[]结合再取地址。做左值时表示数组首元素对应的内存空间,做右值时表示数组首元素的值,也就是数组首元素对应的内存空间中存储的那个数值。做右值时&a[0]等同于a

    解释:为什么数组的地址是常量?因为数组是编译器在内存中自动分配的。当我们每次执行程序时,运行时都会帮我们分配一块内存给这个数组,只要完成了分配,这个数组的地址就定好了,本次程序运行直到终止都无法再改了。在程序中只能通过&a来获取这个分配的地址,却不能去用赋值运算符修改它。

    2.指针与数组的天生姻缘

    2.1 指针方式访问数组元素

    数组元素使用时不能整体访问,只能单个访问。访问方式有2种:

    • 数组形式:数组名[下标];,注意下标从0开始。
    • 指针形式:*(指针+偏移量);,如果指针是数组首元素地址,比如a或者&a[0],那么偏移量就是下标。指针也可以不是首元素地址而是其他哪个元素的地址,这时候偏移量就要结合实际情况考虑了。

    举个栗子:

    #include<stdio.h>
    
    int main(int argc,char**argv)
    {
    	int a[5]={0,1,2,3,4};
    	for(int i=0;i<5;++i)
    	{
    		//数组形式访问元素
    		printf("%d. ",a[i]);
    	}
    	printf("\n");
    	
    	int* p = &a[1];	//p指向数组的第2个元素a[1]
    	*++p = 3;	//++优先级高于*,所以p先加1,指向a[2],然后解引用,修改的就是a[2]
    	for(int i=0;i<5;++i)
    	{
    		printf("%d. ",a[i]);
    	}
    	printf("\n");
    	
    	return 0;
    }
    

    输出:

    0. 1. 2. 3. 4. 
    0. 1. 3. 3. 4. 
    

    数组下标方式和指针方式均可以访问数组元素,两者的实质其实是一样的,在编译器内部都是用指针方式来访问数组元素的。数组下标方式只是编译器提供给编程者一种壳(语法糖)而已,所以用指针方式来访问数组才是本质的做法。

    2.2 从内存角度理解指针访问数组的实质

    数组的特点就是:数组中各个元素的地址是连续的,而且数组还有一个很大的特点,这其实也是数组的一个限制:就是数组中各个元素的类型必须相同。类型相同就决定了每个数组元素占几个字节是相同的,比如int数组中每个元素都占4字节,没有例外。这两个特点就决定了只要知道数组中一个元素的地址,就可以很容易推算出其他元素的地址。

    2.3 指针和数组类型的匹配问题

    int a[5];
    int *p; 	
    p = a;		// 类型匹配
    p = &a;		// 类型不匹配。p是int *,&a是整个数组的指针,也就是一个数组指针类型,不是int指针类型,所以不匹配
    

    &aa&a[0]从数值上来看是完全相等的,但是意义来看就不同了。从意义上来看,a&a[0]是数组首元素首地址,而&a是整个数组的首地址;从类型来看,a&a[0]是元素的指针,也就是int *类型;而&a是数组指针,是int (*)[5];类型。

    2.4 指针类型决定指针如何参与运算

    指针参与运算时,因为指针变量本身存储的数值是表示地址的,所以运算也是地址的运算。

    指针参与运算的特点是:指针变量+n,并不是真的地址加n,而是地址加上n*sizeof(指针指向的类型)

    比如int *指针,+1就实际表示地址+4,如果是char *指针,则+1就表示地址+1;如果是double *指针,则+1就表示地址+8。指针变量+1时实际不是加1而是加1×sizeof(指针类型),主要原因是希望指针+1后刚好指向下一个元素,而不希望错位。

    2.5 数组在函数传参时的表现

    函数传参的时候形参是可以用数组的,但是函数形参是数组时,实际传递是不是整个数组,而是数组的首元素首地址,也就是说函数传参用数组来传,实际相当于传递的是指针,该指针指向数组的首元素首地址。这里func(b)中的b等价于作右值,实际传递的就只有一个指针,所以这里的func()其实等价于下面func2()的写法。在一些需要传递数组的函数中,经常看到的写法是void func(int*a,int n);,其中n就是数组的大小,这是因为数组大小是不能直接通过传递数组来传递的,必须额外单独传递。

    举个栗子:

    #include<stdio.h>
    
    void func(int b[])
    {
    	printf("in func,sizeof(b) = %d.\n",sizeof(b));	   
    }
    
    void func2(int* b)
    {
    	printf("in func,sizeof(b) = %d.\n",sizeof(b));	   
    }
    
    int main(int argc,char**argv)
    {
    	int b[100];
    
    	func(b);	
    	return 0;
    }
    

    输出:

    in func,sizeof(b) = 8.
    

    3.指针、数组与sizeof运算符

    3.1 sizeof运算符的使用

    sizeofC语言的一个运算符,它不是函数,虽然用法很像函数。因为在不同平台下各种数据类型所占的内存字节数不尽相同,比如int类型在32位系统中为4字节,在16位系统中为2字节。所以程序中可以使用sizeof来判断变量或者数据类型在当前环境下占几个字节。

    举个栗子:

    #include<stdio.h>
    #include<string.h>
    
    int main(int argc,char**argv)
    {
    	char str[] = "hello";  
    	printf("size of str = %d.\n",sizeof(str));	
    	printf("size of str[0] = %d.\n",sizeof(str[0]));	
    	printf("strlen of str = %d.\n",strlen(str)	);	
    	
    	char *p=str;
    	printf("sizeof(p) = %d.\n",sizeof(p));
    	printf("sizeof(*p) = %d.\n",sizeof(*p));
    	printf("strlen(p) = %d.\n",	strlen(p));
    	
    	return 0;
    }
    

    输出:

    size of str = 6.
    size of str[0] = 1.
    strlen of str = 5.
    sizeof(p) = 8.
    sizeof(*p) = 1.
    strlen(p) = 5.
    

    32位系统中所有指针占4个字节,64位系统中所有指针占8个字节,不管是什么类型的指针。strlen()是一个C库函数,用来返回一个字符串的长度,字符串的长度是不计算字符串末尾的'\0'的。

    3.2 sizeof使用的一些细节

    1.sizeof测试一个变量本身,和sizeof测试这个变量的类型,结果是一样的。

    举个栗子:

    #include<stdio.h>
    
    int main(int argc,char**argv)
    {
    	int n=10;
    	printf("sizeof(n) = %d.\n",sizeof(n));//等价于sizeof(int)
    	printf("sizeof(int) = %d.\n",sizeof(int));
    	
    	return 0;
    }
    

    输出:

    sizeof(n) = 4.
    sizeof(int) = 4.
    
    inf func,sizeof(b) = 8.
    

    2.sizeof(数组名) 的时候,数组名不做左值也不做右值,纯粹就是数组名的含义。那么sizeof(数组名) 实际返回的是整个数组所占用以字节为单位的内存空间。

    举个栗子:

    #include<stdio.h>
    
    int main(int argc,char**argv)
    {
    	int b[100];
    	printf("sizeof(b) = %d.\n",sizeof(b));
    		
    	return 0;
    }
    

    输出:

    sizeof(b) = 400.
    

    3.指针定义与definetypedef结合的时候,定义的类型结果不一样,sizeof结果自然也不一样。

    #include<stdio.h>
    
    #define dpChar char*
    typedef char* tpChar;
    
    int main(int argc,char**argv)
    {
    	dpChar p1,p2;	//等价于char* p1,p2; p1是char*类型,p2是char类型	
    	tpChar p3,p4;	//等价于char* p1;char* p2; p1,p2都是char*类型	
    	
    	return 0;
    }
    

    4.数组指针与指针数组

    4.1 指针数组与数组指针

    • 指针数组的实质是一个数组,这个数组中存储的内容全部是指针变量。
    • 数组指针的实质是一个指针,这个指针指向的是一个数组。

    4.2 分析指针数组与数组指针的表达式

    在定义一个符号时关键在于:

    • 首先要搞清楚定义的符号是谁,即第一步:找核心;
    • 其次再来看谁跟核心最近、谁跟核心优先结合,即第二步:找结合;
    • 以后继续向外扩展,即第三步:继续向外结合直到整个符号完。

    如何核心和*结合,表示核心是指针;如果核心和[]结合,表示核心是数组;如果核心和()结合,表示核心是函数。

    下面用一般规律来分析下这3个符号:

    int *p[5]; 
    int (*p)[5];	
    int *(p[5]);
    
    • 对于第一个表达式来说,核心是p,它的旁边有*[],那么接下来的问题就是看这两个符号谁的优先级高。在C语言中[]优先级高于*,于是p是一个数组,数组中有5个元素,并且每个元素都是指向int类型的指针。总之,整个符号是一个指针数组。
    • 对于第二个表达式来说,核心是p,这里()优先级更高,所以p优先和*结合,因此它首先是一个指针,指针指向一个数组,数组有5个元素,数组中存的元素是int类型。总结一下整个符号的意义就是数组指针。
    • 对于第三个表达式来说, 解析方法和结论和第一个相同,因为[]优先级高于*,所以()在这里是可有可无的。

    注意:符号的优先级决定了当两个符号一起作用的时候决定哪个符号先运算,哪个符号后运算。遇到优先级问题记得住更好,记不住就去查优先级表。

    4.3 总结

    • 1.优先级和结合性是分析符号意义的关键,在分析C语言问题时不要胡乱去猜测规律,从已知的规律出发按照既定的规则去做即可。
    • 2.学会逐层剥离的分析方法,找到核心后从内到外逐层的进行结合,结合之后可以把已经结合的部分当成一个整体,再去和整体外面的继续进行结合。
    • 3.基础理论和原则是关键,没有无缘无故的规则。
    展开全文
  • 01什么是指针数组1、一个数组,若其元素均为指针类型数据,称为指针数组就是说,指针数组中的每一个元素都存放一个地址,相当于一个指针变量。2、一般形式类型名 *数组名[数组长度];类型中应包括符合*,如int *...

    2c093cf9ff40262a0b26c42e6e20e882.png

    01什么是指针数组

    1、一个数组,若其元素均为指针类型数据,称为指针数组,也就是说,指针数组中的每一个元素都存放一个地址,相当于一个指针变量。

    2、一般形式

    类型名 *数组名[数组长度];

    类型中应包括符合*,如int *表示是指向整数数据的指针类型。

    3、例子

    int *p[4];

    4、由于[]比*优先级高,因此p先和[4]结合,形成p[4]形式,这显然是数组形式,表示p数组有4个元素。然后再和p前面的*结合,*表示此数组是指针类型的,每个数组元素都可以指向一个整型变量。

    02指向指针数据的指针

    1、在了解了指针数组的基础上,需要了解指向指针数据的指针变量,简称指向指针的指针。

    2、定义一个指向指针数据的指针变量:

    char **p;

    p的前面有两个*号。*运算符的结合性是从右到左,因此**p相当于*(*p),显然*p是指针变量的定义形式 。

    03指针数组作main函数的参数

    1、main函数的第一行一般写成int main()或int main(void),括号中是空的或有void,表示main函数没有参数,调用main函数时不必给出实参。

    2、在某些情况下,main函数可以有参数,例如:int main(int argc,char *argv[])其中,argc和argv就是main函数的形参,他们是程序的“命令行参数”。

    3、命令行的一般形式

    命令名 参数1 参数2……参数n

    C语言 | 冒泡排序比较大小mp.weixin.qq.com
    展开全文
  • 序言数组指针指针数组这两个概念接触的时候是在大学学习C/C++的时候,因为那个时候编程还没有在大学期间那么火热的情况下,因为都是大学生,从来不知道考虑毕业后的事情(要不怎么说是懵懂的大学生呢),那也是我...

    序言

    数组指针和指针数组这两个概念接触的时候是在大学学习C/C++的时候,因为那个时候编程还没有在大学期间那么火热的情况下,因为都是大学生,从来不知道考虑毕业后的事情(要不怎么说是懵懂的大学生呢),那也是我接触的第二门编程语言(第一门是VB),说真的,老师上课讲的真是一脸懵逼啊,完全不理解,当时以为这是完全两个相同的概念,现在才发现,当时的我是有多么的不理解,哈哈…好了,言归正传,今天我重新拿起来C++,跟大家一起来再次揭开他们的真正面目。

    概念

    • 数组指针:
      指针指向的元素是数组,我们称其为数组指针

    • 指针数组:
      数组的元素是指针类型,我们称其为指针数组

    格式

    数组指针

    先给大家看一下基本的定义格式
    1. 指向一维数组的指针类型变量:
    指向类型(*指针变量名)[常量表达式]…

    指向类型其实就是我们说的数据类型,看你的指针是哪个类型的,指针变量名顾名思义就是指针的名字,常量表达式,就是我们所说的数组维数,一维后面就写一个常量表达式,中括号里面是正整数。
    2. 只想多维数组的指针类型变量
    指向类型(*指针变量名)[常量表达式1][常量表达式2],…
    举个栗子:

    int (*p1)[5];//定义指向一维数组的指针变量p1
    int (*p2)[2][3];//定义指向二维数组的指针变量p2

    注意:这里的指针变量名必须括起来,因为[]的优先级高于*号,所以我们要让*号先执行,否则就变成定义数组了。

    是不是看的有点懵圈,给大家看个图:

    一维数组的含义

    这个是一维数组的含义,很简单,p1的指向类型就是一个有着4个整形元素的一维数组。

    这里写图片描述

    这个是二维数组的含义,p2的指向类型就是一个有着12个整形元素的二维数组(3行4列)。

    大家要注意的是,数组指针本意上是一个指针,而不是数组,我们记得他是一个指向数组的指针

    指针数组

    一样还是先给大家看一下指针数组的基本定义格式
    1. 一维指针数组的定义:
    指向类型 * 数组名[常量表达式]…

    由于[]比 * 的优先级要高,因此先处理[],显然这样看起来就是数组形式。指针书每个元素均是一个“指向类型*”指针类型,即每个元素就是一个指针变量。
    2. 多位指针数组的定义:
    指向类型 * 数组名[常量表达式1][常量表达式2]…[常量表达式n],…
    同样,先给大家举个栗子:

    int *p1[5];//一维指针数组p1
    int *p2[2][3];//二位指针数组p2

    注意:指针数组“int * p[4]”与“int (*p)[4]”;写法差不多,但是意义上却完全不一样,后者是数组指针,大家记住了,别搞反了。

    一样,给大家看个图:

    指针数组的含义

    这个是指针数组的含义,每个指针元素的值还是一个指针。

    初始化

    • 数组指针
    int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};//二维数组
    int (*p)[4]=a;//指向数组的指针的初始化,a代表数组的第一行的第一个元素
    • 指针数组
    int a[4][4]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};//二维数组
    int s[4]={a[0],a[1],a[2],a[3]};//一维指针数组初始化

    示例

    • 数组指针
    #include <iostream>
    #include <iomanip>
    using namespace std;
    int main(){
        int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12},i,j,(*p)[4]=a;
        for(i=0;i<3;i++){
            for(j=0;j<4;j++){
                cout<<setw(2)<<p[i][j]<<endl;
            }
        }
        return 0;
    }

    运行结果:

    1   2   3   4
    5   6   7   8
    9   10  11  12
    • 指针数组
    #include <iostream>
    #include <iomanip>
    using namespace std;
    int main(){
        int a[4][4]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};//二维数组
        int i,j,s[4]={a[0],a[1],a[2],a[3]};//一维指针数组初始化
        for(i=0;i<4;i++){
            for(j=0;j<4;j++){//s[i]为a[i]的行首地址
                cout<<setw(2)<<s[i][j]<<endl;//故s[i][j]等价于a[i][j]
            }
        }
        return 0;
    }

    运行结果:

    1   2   3   4
    5   6   7   8
    9   10  11  12
    13  14  15  16

    总结

    以上就是数组指针和指针数组的对比,两者从名字看仅仅只是名字颠倒着叫,但是其含义却大不相同,理解起来还是有点吃力,不过当你第一遍不理解的时候,再去看第二遍,第二遍不行就第三遍,我相信,铁杵磨成针,你一定会理解的,C/C++基础点其实不难,难点在于后期开发,因为偏于底层,如果大家有兴趣做这方面的工作,还是需要下一番苦心的,好了,说了这么多,如果大家还有什么不懂得欢迎留言讨论

    每篇文章都来之不易,希望大家能够珍惜他人的劳动成果,如需转载请注明出处,如用作商业请联系我:905007127@qq.com非常安歇大家的支持

    展开全文
  • 那么数组名就代表着所有的内存吗,答案明显的,肯定不是,我们前面说过,这些变量名数组名等都只是内存的助记符,代表着指针,所以我们可以认为数组是一个指针,指向了数组的第0个元素,就是指向数组的首地址,...
  • C语言学习笔记之 指针数组与指向指针指针 指针的广泛用途不仅仅在于数组指针、函数指针等,可以说没有指针不...我们之前学的是数组指针,这两个概念可是千差万别的哦!同样的,你是不是对指向指针指针也产生了迷...
  • 那么函数指针,从语文的角度讲,中心词是指针,函数是修饰指针的定语。事实上C语言中也是这样的:函数指针,是一个指针,一个指向函数的指针。 这时大家可能就会纳闷了,函数有地址吗?怎么可...
  • //1 int i = 0; int j =1; int l = 2; int *p,*q,*m;...不应该也是地址吗? cout**(k);//j 第一个字符串中第一个字符 k是数组首元素的地址,类型为char,**k就表示为j。这是因该的。 cout*(*(k)+1);//a
  • 一、数组是指针吗? 在C语言基础书上我们看到过"我们可以把地址,形象的看成指针",所以地址就是指针,指针就是地址,这句话在某种程度上应该没一点问题问题。但是我们老是听别人说"数组名就是首元素的地址",...
  • 字符数组和字符指针

    2015-12-29 15:28:44
    字符数组和字符指针 问题1: 字符数组名可以作为左值吗?当然不行 ...char str[20] = {'h','e','l','l','o',' ',...不可以这么干,因为字符数组一个常量指针就是一个const char* #include int main()
  • 那么数组名就代表着所有的内存吗,答案明显的,肯定不是,我们前面说过,这些变量名数组名等都只是内存的助记符,代表着指针,所以我们可以认为数组是一个指针,指向了数组的第0个元素,就是指向数组的首地址,...
  • 那么数组名就代表着所有的内存吗,答案明显的,肯定不是,我们前面说过,这些变量名数组名等都只是内存的助记符,代表着指针,所以我们可以认为数组是一个指针,指向了数组的第0个元素,就是指向数组的首地址,...
  • 数组及其数组元素都占有存储空间,都有自己的地址,因此指针变量可以指向整个数组可以指向数组元素。一、用指针指向一维数组的元素输出结果:说明已经通过指针间接修改了数组元素的值,跟指向一个普通int类型...
  • 那么数组名就代表着所有的内存吗,答案明显的,肯定不是,我们前面说过,这些变量名数组名等都只是内存的助记符,代表着指针,所以我们可以认为数组是一个指针,指向了数组的第0个元素,就是指向数组的首地址,...
  • 摘要:总结了指针数组和数组... 我的理解也是的,但是数组首元素的地址。  2.假设数组名为a,那么a和&a的地址值相同,意义不同,那么指向它们的指针类型相同吗?  答案是不同,这一点下面会解释到,因为a和&a的
  • 所谓对象数组是指每一个数组元素都对象的数组吗,就是说,若一个类有若干个对象, 我们把这一系列的对象用一个数组存放。对象数组的元素对象。不仅具有数据成员,而且还有函数成员。 定义一个一维数组的...
  • ps:我理解为同一个地址但代表不同的内涵,指针*(a+1)自身的地址&(*(a+1))代表一维数组的首地址,指向一维数组的,通过该地址来找到该一维数组的位置。a[1][0]自身的地址&a[1][0]代表整型变量a[1][0]的地址...
  • 数组及其数组元素都占有存储空间,都有自己的地址,因此指针变量可以指向整个数组可以指向数组元素。一、用指针指向一维数组的元素输出结果:说明已经通过指针间接修改了数组元素的值,跟指向一个普通int类型...
  •  1.C语言之中只会以值拷贝的方式传递参数,指针其实传递的也是值,只不过里面是地址罢了。那么加入我们需要向函数传递一个数组或者比较大的结构体的时候,是将整个数组都拷贝过去吗?是将整个结构体都拷贝过去吗?...
  • 数组指针

    2018-03-12 13:53:02
    1.什么是指针变量?答:对于数组来说,数组名就是数组在内存存放的数组首地址。指针变量是用于存放变量地址,可以指向变量,当然可以存放数组的首地址或数组首地址。2.数组的下标总是从0开始吗?答:是的,对数组a...
  • 对字符数组,字符指针,字符串常量以及其sizeof的一些总结 在网上经常看到一些类似字符串或者sizeof等的公司笔试题,鄙人不才,但作了一些总结, 这些总结都在vc2003下测试得到的结果,如果不对,请指出。 ...
  • 数组不是Java中的原始类型,但它们不是对象,所以它们通过值传递还是通过引用传递?它是否依赖于数组包含的内容,例如引用或基元类型?数组是对象,的,但是Java中的任何东西都不是通过引用传递的。所有参数...
  • 关于数组指针

    2015-09-19 16:33:21
    1. 先来看几个例子,你能说出这几个表示方法的... int (*p)[10] //指向一个有10个int成员的数组,其实就是一个2维数组p[][10],确定的第二维的长度10,数组里面对象的类型int,这种方式叫数组指针,可以转化成二
  •  在C语言中,数组指针是其中非常重要又联系紧密的两种数据类型,同时也是重点难点集中的地方。在学习这些内容时,经常会碰到这样一些问题,例如:数组名是什么,就是首地址吗?数组如何访问元素?数组为什么不能...

空空如也

空空如也

1 2 3 4 5 ... 17
收藏数 336
精华内容 134
关键字:

数组也是指针吗