指针与数组

环境：vc6.0   32位

一、一维数组与指针

       一维数组相对比较简单，如int a[5]={1,4,7,10,13};

       同时定义一个整型指针：int *p;

       将指针指向一维数组：*p=a;//a表示数组的首地址

      下面来看一段代码：  

//一维数组与指针
	int a[5]={1,4,10,16,21};
	int b[10][20];
	int *p=a;
	int *q=&a[3];
	int *p1=(int*)(&a+1);//&a+1表示向前移动一维
	int *ptr=(int *)((int)a+1);//将a的数值转化为int型，然后加1，这里的加1只是表示普通的数值加1，与类型无关
	printf("a=%d\n",a);//首地址的值
	printf("&a[0]=%d\n",&a[0]);//首地址的值
	printf("p=%d\n",p);//指针的值=首地址的值
	printf("p+1=%d\n",p+1);//指向下一个元素，由于指向的类型是int（占4位），数值为首地址+4
	printf("*(p+1)=%d\n",*(p+1));//取a[1]的数值
	printf("&p=%d\n",&p);//指针存放的内存地址
        printf("&p+1=%d\n",&p+1);//指针存放的内存地址+4，指针在内存中都是4个字节存放的。所以sizeof(p)会等于4
	printf("*p+7=%d\n",*p+7);//首地址值+1 
        printf("*q=%d\n",*q);//16,a[3]的数值
	printf("q-p=%d\n",q-p);//3，为两者指向的位置的数值相减，与类型无关
        printf("&a=%d\n",&a);//数组a内存存放的地址
        printf("&a+1=%d\n",&a+1);//指向下一维的地址,或者说是a[5]
	printf("*(p1-1)=%d\n",*(p1-1));//指向a[4]
	printf("*ptr=%d\n",*ptr);//ptr指向的a[0]的3个字节和a[1]的一个字节组成的int
	printf("&a[4]-&a[1]=%d\n",&a[4]-&a[1]);//3
	printf("&b[5][0]-&b[0][0]=%d\n",&b[5][0]-&b[0][0]);//100

       结果如下：

      从结果可以看出，a=&a[0]=p 都为数组a的首地址。p+1=首地址+类型所占字节*1，由于为整型数组，例子中为整型数组，加4即可。如果是char，则加1。&p的值为p指针所存放的内存地址。& p+1=内存存放的地址+1*4，不管任何类型的指针的大小都为4个字节。q-p=两指针指向的位置相减，与类型无关。但是对于实际的取出&a[4]-&a[1]而言，其大小为3，与类型也是无关的。

二、二维数组

     先来看下面类型的实参及形参：

                                       实参                                 形参
数组的数组               char c[8][10];                  char (*)[10];           数组指针

指针数组                   char *c[10];                    char **c;                 指针的指针  

数组指针(行指针)    char (*c)[10];                  char (*c)[10];         不改变

指针的指针               char **c;                         char **c;                 不改变

//二维数组及指针
        int a[2][2]={2,7,12,17};
	int a1[5]={1,4,9,14,20};
	int a2[2]={1,2};
	int *p1=a1;
	int **p2=&p1; //指向指针的指针
	int *p3[2];//指针数组，每个元素都是指向int型对象的指针
	//int *p3[2]={&a2[0],&a2[1]};指针数组初始化方式1，为地址
	int (*p4)[2];//数组指针，也称为行指针，定义了一个指针，该指针指向一个有2个元素的一维指针

	printf("**p2=%d\n",**p2);//输出数组a1[0]的数值

        //指针数组指向一维数组的初始化方式2
	for(int i=0;i<2;i++)
	{
        p3[i]=&a2[i];//将数组a2中的地址赋值给指针
	}
	//输出指针数组中的数值
	for(i=0;i<2;i++)
	{
		printf("*p3[i]=%d\n",*p3[i]);
	}
       //数组指针的初始化
        p4=a;
	//数组指针的输出方式
        for(i=0;i<2;i++)
		for(int j=0;j<2;j++)
		{
			printf("%d\n",p4[i][j]);
		}
         printf("p4=%d\n",p4);//指向数组a的首地址，也就是第一行第一列的位置
	 printf("p4+1=%d\n",p4+1);//指向数组a第二行的首地址，其值=a的首地址+类型所占字节数*个数，与类型有关

	 //同时推荐一段有趣的代码，有助于理解指针与数组，可以根据各个类型的实参与形参来理解

	 int arr1[3]; 
	 int arr2[3]; 
	 int arr3[3]; 
	 int * ptr; 
	 // ptr1是一个指向 int [3] 的指针，即ptr的类型和&arr1的类型是一样的，注意：arr1指向的内存区域定长 
	 int ptr1[3][3]={{1,2,3},{1,2,3},{1,2,3}}; 
	 // ptr2是一个指向 int * 的指针，即ptr2的类型和&ptr是一样的，注意：ptr指向的内存区域不定长 
	 int * ptr2[3]={arr1,arr2,arr3}; 
	 // ptr3是一个指向 int [3] 的指针，即ptr3的类型和&arr1的类型是一样的，注意：arr1指向的内存区域定长 
	 int(* ptr3)[3]=&arr1; 
	 ptr3=ptr1; // 没错，他们的类型相同 
	 // ptr3=ptr2;//error 无法从“int *[3]”转换为“int (*)[3] 
	 // ptr4是一个指向 int * 的指针，即ptr4的类型和&ptr是一样的，注意：ptr指向的内存区域不定长 
	 int ** ptr4; 
	 //ptr4=&arr1; //error 无法从“int (*)[3]”转换为“int ** 
	 ptr4=ptr2; // 没错，他们的类型相同 
         //ptr4=ptr3; // error 无法从“int (*)[3]”转换为“int **