0602-指针和数组

数组名

数组名是一个地址常量，不允许赋值。它表示数组首元素的地址。

指针操作数组元素

指针访问数组

指针类型变量\常量+1等同于指针保存的内存地址+sizeof(指针指向的数据类型)。

2个相同类型的指针相减，得到的结果是2个指针的偏移量。其中偏移单位（也叫步长）为sizeof(指针指向的数据类型)。

#include<stdio.h>

int main() {
	int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
	int* p = arr;
	int length = sizeof(arr) / sizeof(int);

	for (size_t i = 0; i < length; i++)
	{
		printf("arr[%d]=%d, p[%d]=%d, *(arr+%d)=%d, *(p+%d)=%d\n", 
			i, arr[i], i, p[i], i, *(arr+i), i, *(p+i));
	}

	int* q = arr;
	for (size_t i = 0; i < length; i++)
	{
		printf("第%d项=%d\n", i, *q);
		q++;
	}

	/*
	下面计算得出，q与arr的偏移量为10（个步长）
	*/
	int step = q - arr;
	printf("step=%d\n", step);
	return 0;
}

运行上面的代码，结果如下：

PS：指针操作数组时推荐使用p[i]，因为p[i]比*(p+i)简单明了。
[i]相当于偏移+取值，p[i]就表示以p保存的地址为起点，偏移i个步长并且取值。

数组名与指针的区别

1、数组名是常量，指针是变量；
2、sizeof的结果不同；

#include<stdio.h>

int main() {
	int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int* p = arr;

	printf("sizeof(arr) = %u\n", sizeof(arr));
	printf("sizeof(p) = %u\n", sizeof(p));
	return 0;
}

执行上面代码，结果如下：

数组名退化

数组作为函数参数时，数组名退化为指针变量，丢失数组长度。

#include<stdio.h>

/*
printArrayLen(int arr[])等价于printArrayLen(int* arr)
*/
void printArrayLen(int arr[]) {
	int len = sizeof(arr) / sizeof(arr[0]);
	printf("参数数组的长度：%d\n", len);
	/*
	* 数组作为函数参数时，数组名退化为指针，
	* 所以此处arr相当于指针变量。
	*/
	printf("sizeof(arr) = %d\n", sizeof(arr));

}

int main() {
	int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
	printArrayLen(a);
	return 0;
}

运行上面代码，结果如下：

指针加减运算

指针自增或自减的步长只和指针指向的数据类型有关，与实际赋值给指针变量的数据类型无关。

#include<stdio.h>

int main() {
	int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
	//给p和p2赋上相同的值
	int* p = &arr[9];
	char* p2 = &arr[9];
	printf("p保存的地址：%p\n", p);
	printf("p2保存的地址：%p\n", p2);

	p--;
	p--;
	p--;
	p2--;
	p2--;
	p2--;
	//p自减的步长为4字节，p2自减的步长为1字节
	printf("\"p--\"3次后, p保存的地址：%p\n", p);
	printf("\"p2--\"3次后, p2保存的地址：%p\n", p2);
}

运行上面代码，结果如下：

指针的运算符，仅支持“指针与整数的加减运算”、“同类型指针相减”、“两指针比大小”、“逻辑运算符”，其余指针运算都是没有意义的。

指针数组

指针数组是一个数组，它的每一个元素都是指针类型。

#include<stdio.h>

void main() {
	int a = 10;
	int b = 20;
	int c = 30;

	int* arr[3] = {&a, &b, &c};

	printf("a = %d\n", *arr[0]);
	return 0;
}

运行上面代码，结果如下：

指针数组相当于一个二维数组。

#include<stdio.h>

void main() {

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

	int* d[] = {a, b, c};

	for (int i = 0; i < sizeof(d) / sizeof(d[0]); i++) {
		printf("%d %d %d\n", *d[i], *(d[i]+1), *(d[i]+2));
	}
	printf("=====\n");
	for (int i = 0; i < sizeof(d) / sizeof(d[0]); i++) {
		printf("%d %d %d\n", d[i][0], d[i][1], d[i][2]);
	}
	printf("=====\n");
	for (int i = 0; i < sizeof(d) / sizeof(d[0]); i++) {
		printf("%d %d %d\n", (*(d+i))[0], (*(d + i))[1], (*(d + i))[2]);
	}
}

运行上面代码，结果如下：

多级指针

#include<stdio.h>

int main() {

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

	int* arr[] = {a, b, c};
	/*
	p保存的是&(int*),也就是int*型变量的地址，而不是int*型变量的值
	arr是数组首元素a的地址，而a类型是int*，所以arr是int*的地址。
	所以可以将arr赋值给p。

	从而指针数组和二级指针建立关系。
	二级指针指向指针数组的首元素。
	*/
	int** p = arr;

	printf("p最终指向的整形为：%d\n", **p);
	printf("*p = %p\n", *p);
	printf("数组a的首地址=%p\n", a);
	printf(" *(p+1) = %p\n", *(p+1));
	printf("数组b的首地址=%p\n", b);
	printf(" *(p+2) = %p\n", *(p + 2));
	printf("数组c的首地址=%p\n", c);

	printf("====遍历指针数组====\n");
	for (int i = 0; i < 3; i++) {
		for (int j = 0; j < 3; j++) {
			//下面三行代码等价
			printf("%d ", p[i][j]);
			//printf("%d ", *(p[i]+j));
			//printf("%d ", *(*(p + i) + j));
		}
		printf("\n");
	}
	return 0;
}

运行上面代码，结果如下

#include<stdio.h>

int main() {
	int a = 10;
	int b = 20;
	int* p = &a;
	int** pp = &p;

	//下面2行代码输出“*p = 20”
	//*pp = &b;
	//printf("*p = %d\n", *p);


	//下面3行代码输出
	//*p = 30
	//a = 30
	**pp = 30;
	printf("*p = %d\n", *p);
	printf("a = %d\n", a);
	return 0;
}

int main() {
	int a = 10;
	int* p = &a;
	int** pp = &p;
	int*** ppp = &pp;

	//下列等式成立
	//*ppp == pp == &p
	//**ppp == *pp == p == &a
	//***ppp == **pp == *p == a
}