C 练习实例77-指向指针的指针-二维数组

关于数组的一些操作

#include<stdio.h>
#include<stdio.h>
void fun(int b[],int length)
{
	for(int i=0;i<length;i++){
		printf("%d ",b[i]);
	}
	printf("\n");
	for(int i=0;i<length;i++){	//数组作为形参传递，传递的是指针，所以能够改变值
		b[i]++;
	}
}
int main()
{
	int a[5]={1,2,3,4,5};
//	int b[5]=a;  不合法，数组的本质是常量指针，不允许被修改
//	也就是说b指向了一片空间，这片空间是随机分配的，它一辈子只能指向那片空间
	fun(a,sizeof(a)/sizeof(int));
	for(int i=0;i<sizeof(a)/sizeof(int);i++){
		printf("%d ",a[i]);
	}
	printf("\n");
	return 0;
}

运行结果

1 2 3 4 5
2 3 4 5 6

指向指针的指针

代码 

#include<stdio.h>
int main()
{
	int a=100;
	int *p1=&a;
	int **p2=&p1;
	
	printf("&a=%p\n",&a);
	printf("p1=%p\n",p1);
	printf("*p2=%p\n",*p2);
	
	printf("a=%d\n",a);
	printf("*p1=%d\n",*p1);
	printf("**p2=%d\n",**p2);
	
	return 0;
}

 结果

&a=000000000065FE14
p1=000000000065FE14
*p2=000000000065FE14
a=100
*p1=100
**p2=100

二维数组

代码

#include<stdio.h>
int main()
{
//	要点：数组名可以当指针用，它的值就是首地址，它指向的就是数组首元素
	int b[3]={1,2,3};//一维数组
	printf("b=%p\n",b);//首地址
	printf("&b=%p\n",&b);//首地址
	printf("&b[0]=%p\n",&b[0]);//首地址
	printf("*b=%d\n",*b);//首地址可以取出首元素
	printf("b[0]=%d\n",b[0]);
	
	printf("\n");
	/*
	二维数组的每一行其实就是一个一维数组
	a[0]可以认为是第一行数组的数组名，也可以认为是指向第一行数组的指针
	a[0]的值实际上就是第一行数组的首地址
	以此类推，a[1]是第二行，a[2]是第三行......
	*/
	
//	{a[0],a[1],a[2]}也可以看作是一个一维数组，a是它的名，也可以看作是指针
//	a的值就是就是一维数组a[0]的首地址
	int a[3][4]={{0,1,2,3},{4,5,6,7},{8,9,10,11}};//二维数组
	printf("a[0]=%p\n",a[0]);//第一行数组的首地址,也就是首地址
	printf("&a[0]=%p\n",&a[0]);//第一行数组的首地址,也就是首地址
	printf("*a=%p\n",*a);//第一行数组的首地址,也就是首地址
	printf("a=%p\n",a);//第一行数组的首地址,也就是首地址
	printf("&a=%p\n",&a);//第一行数组的首地址,也就是首地址
	printf("&a[0][0]=%p\n",&a[0][0]);//第一行数组的首地址
	printf("a[0][0]=%d\n",a[0][0]);//首元素
	printf("*a[0]=%d\n",*a[0]);//首地址可以取出首元素
	printf("**a=%d\n",**a);//首地址的首地址可以取出首元素-指针的指针
		
	return 0;
}

运行结果

b=000000000065FE14
&b=000000000065FE14
&b[0]=000000000065FE14
*b=1
b[0]=1

a[0]=000000000065FDE0
&a[0]=000000000065FDE0
*a=000000000065FDE0
a=000000000065FDE0
&a=000000000065FDE0
&a[0][0]=000000000065FDE0
a[0][0]=0
*a[0]=0
**a=0

在一维数组中，a的值=&a的值=&a[0]的值，*a=a[0]

在二维数组中，&a=a=*a=a[0]=&a[0]=&a[0][0]，a[0][0]=*a[0]=**a[0]，有点绕哈，是不是和指向指针的指针有点像。

数组指针（指向数组的指针）

它的定义如下：

#include <stdio.h>
int main()
{
	int a[3]={1,2,3};
	int *p=a;
	printf("*p+0=%d\n",*p+0);
	printf("*p+1=%d\n",*p+1);
	printf("*p+2=%d\n",*p+2);
}

输出结果

*p+0=1
*p+1=2
*p+2=3

数组指针，就是指向数组的指针，它存放的是数组的首地址，每加1其实是加了一个int类型的字节长度。

指针数组

指针数组，就是数组的每个元素是指针类型的，存放的是地址值。

#include <stdio.h>
int main()
{
	int a=1;
	int b=2;
	int c=3;
	printf("%d,%d,%d\n",&a,&b,&c);
	int *array[3]={&a,&b,&c};
//int *->int型指针，array[3]->数组有3个元素，每个元素是int *型，即指向整形变量的指针类型
	printf("%d,%d,%d\n",array[0],array[1],array[2]);
	printf("%d,%d,%d\n",*array[0],*array[1],*array[2]);//*为取值运算符
	
	printf("%d\n",&array[0]);//(数组也有它自己的地址)
	printf("%d\n",array);//&array[0]=array=&array
	printf("%d\n",&array);//&array[0]=array=&array
	
//	int *p=array;××因为array是int *型的，所以我们要定义int *型的指针，才能指向这个数组
	int **p=array;//拆成3部分看容易理解，int *看作类型，*表示是int *类型的指针，p代表变量名
	//即指向指针的指针
	printf("%d,%d,%d\n",&array[0],&array[1],&array[2]);//(数组也有它自己的地址)
	printf("%d,%d,%d\n",p,p+1,p+2);//(通过指针拿到数组单元的地址)
	printf("%d,%d,%d\n",*(p+0),*(p+1),*(p+2));//(通过取值运算符*拿到数组单元的值)
	printf("%d,%d,%d\n",**(p+0),**(p+1),**(p+2));//(通过取值运算符*拿到数组单元的地址所指向的值)
	
//在自己动手实验的过程中，我发现变量的内存分配好像是自顶向下，是递减规律
//而数组单元间的地址值是递增规律
	
}

运行结果 

6684180,6684176,6684172
6684180,6684176,6684172
1,2,3
6684144
6684144
6684144
6684144,6684152,6684160
6684144,6684152,6684160
6684180,6684176,6684172
1,2,3

二维数组续

#include <stdio.h>
int main()
{
	int a[3][4]={{0,1,2,3},{4,5,6,7},{8,9,10,11}};
	int *p0=a[0];//第一层首元地址
	int *p1=a[1];//第二层首元地址
	int *p2=a[2];//第三层首元地址
	printf("*p0=%d\n",*p0);
	printf("*p1=%d\n",*p1);
	printf("*p2=%d\n",*p2);
	printf("*a[0]=%d\n",*a[0]);
	printf("*a[1]=%d\n",*a[1]);
	printf("*a[2]=%d\n",*a[2]);
	int (*p)[4]=a;//p指向int[4],即指向4个int类型的连续空间，4*4=16Byte
	printf("a[0]=%d\n",a[0]);
	printf("a[1]=%d\n",a[1]);
	printf("a[2]=%d\n",a[2]);
	printf("\n");
	printf("p0=%d\n",p0);
	printf("p1=%d\n",p1);
	printf("p2=%d\n",p2);
	printf("\n");
	printf("p+0=%d\n",p+0);//二维数组第一层
	printf("p+1=%d\n",p+1);//+1不是简单的加1，而是加到下一个16Byte的空间  第二层
	printf("p+2=%d\n",p+2);//二维数组第三层
	printf("\n");
	
	printf("*(*(p+0)+0)=%d\n",*(*(p+0)+0));
	printf("*(*(p+0)+0)=%d\n",*(*(p+1)+0));
	printf("*(*(p+0)+0)=%d\n",*(*(p+2)+0));
	printf("\n");
	
//	因此遍历二维数组就有了两种方式
//	方式一
	for(int i=0;i<3;i++){	//最外层控制行
		for(int j=0;j<4;j++){	//内层控制列
			printf("%d ",a[i][j]);
		}
		printf("\n");
	}
	printf("\n");
//	方式二
	for(int i=0;i<3;i++){	//最外层控制行
		for(int j=0;j<4;j++){	//内层控制列
			printf("%d ",*(*(p+i)+j));
		}
		printf("\n");
	}
//	总结：c语言里的二维数组是连续空间，所以可以进行上述操作
	return 0;
}

运行 

*a[0]=0
*a[1]=4
*a[2]=8
a[0]=6684096
a[1]=6684112
a[2]=6684128

p0=6684096
p1=6684112
p2=6684128

p+0=6684096
p+1=6684112
p+2=6684128

*(*(p+0)+0)=0
*(*(p+0)+0)=4
*(*(p+0)+0)=8

0 1 2 3
4 5 6 7
8 9 10 11

0 1 2 3
4 5 6 7
8 9 10 11

指针+字符串

#include <stdio.h>
int main()
{	
	//好好学习，天天向上。
	char *str1="好好学";
	char *str2="习，天";
	char *str3="天向上";
	char *str[3]={str1,str2,str3};
	printf("%s%s%s",str[0],str[1],str[2]);;
	return 0;
}

运行结果

好好学习，天天向上