C/C++指针与数组（三）

指针数组与数组指针和运算符的优先级与结合性

一、指针数组

#include<iostream>
int main(int argc, char *argv[])
{
	int a = 3, b = 5, c = 7;
	int* p[3] = { &a,&b,&c }; //指针数组
	std::cout << "&a:" << &a << '\n'
			  << "&b:" << &b << '\n'
			  << "&c:" << &c << '\n';
	std::cout << std::endl;

	for (int i = 0; i < 3; ++i)
	{
		std::cout << "p[" << i << "]:" << p[i] << '\n';
	}
	std::cout << std::endl;

	for (int i = 0; i < 3; ++i)
	{
		std::cout << "*p[" << i << "]:" << *p[i] << '\n';
	}
	std::cout << std::endl;
	return 0;
}

分析：
int* p[3]是一个指针数组：即p是一个数组，这个数组内依次存放指针&a, &b, &c。编译器从右向左去解析，因为运算符[]的优先级高于运算符*，所以p先和[]结合，即p是一个含有三个元素的数组。然后再结合*，意思是这个数组内存放的元素类型是指针。最后再与int结合，它是一个含有三个整型指针的一维数组。

*p[1]：因为运算符[]的优先级高于运算符*，p先和[]结合，所以p[1]取数组中的第一个元素&a，然后再解引用*p[1]即*&a，就取到值3。依照这个思路，同样可以解析出*p[2]、*p[3]。

二、数组指针

#include<iostream>
int main(int argc, char *argv[])
{
	int abc[3] = { 1,2,3 };
	int(*p)[3] = &abc;  //数组指针

	for (int i = 0; i < 3; ++i)
	{
		std::cout << "&abc[" << i << "]:" << &abc[i] << '\n';
	}
	std::cout << '\n';

	std::cout << "&abc:" << &abc << '\n'
		<< "p:" << p << "\n\n";
	
	for (int i = 0; i < 3; ++i)
	{
		std::cout << "*p+" << i << ":" << *p + i << '\n';
	}
	std::cout << '\n';

	for (int i = 0; i < 3; ++i)
	{
		std::cout << "*(*p+" << i << "):" << *(*p + i) << '\n';
	}
	std::cout << '\n';

	for (int i = 0; i < 3; ++i)
	{
		std::cout << "**p:" << **p << "\t**p+" << i + 10 << ":" << **p + i + 10 << "\t(**p)+" << i << ":" << (**p) + i << '\n';
	}
	std::cout << std::endl;

	return 0;
}

分析：
int(*p)[3]：()称为组合（Grouping）运算符，其优先级高于运算符[]，所以*先与p结合，说明p是一个指针。再与[3]结合，说明p指向一个数组。最后与int结合，最终结果为p是一个指向含有三个整型元素的一维数组。类似地，可以定义int(*p)[3][3]、int(*p)[3][3][3]等等，它们是指向二维、三维甚至更高维数组的指针。

&abc[0]：因为运算符[]高于&，abc先与[]结合，所以首先得出abc[0]是数组abc首个元素的数值即1。然后再与&结合，最终&abc[0]就是数组abc的首个元素的地址。依照这个思路，同样可解析出&abc[1]，&abc[2]。

*p+0：运算符*优先级高于加法运算符+，*先与p结合，即解引用p，然后再与+结合，最终*p和*p+0都指向数组abc中的第一个元素。依照这个思路，同样可解析出*p+1、*p+2。

*(*p+0)：组合运算符()优先级高于运算符*，根据上面解析出的结果，即就是对数组abc中的第一个元素的地址解引用，得到1。依照这个思路，同样可解析出*(*p+1)、*(*p+2)。

**p+0、(**p)+0：运算符*优先级高于加法运算符+，加括号(**p)+0并没有改变优先级，因此**p+0取数组中第一个元素的值，从**p+10可得到验证。

三、指针数组指针

int main(int argc, char *argv[])
{
	int a = 3, b = 5, c = 7;
	int abc[3] = { 1,2,3 };
	int* p[3] = { &a,&b,&c }; //指针数组

	int*(*ptrToArray)[3] = &p; //指针数组指针

	std::cout << "ptrToArray:" << '\t' << ptrToArray << std::endl;
	std::cout << "&p:" << "\t\t" << &p << std::endl;

	return 0;
}

分析：
int*(*ptrToArray)[3]：尽管运算符[]的优先级高于解引用运算符*，但是组合运算符()高于[]，所以ptrToArray先与*结合，即ptrToArray是一个指针。然后再与[3]结合,说明ptrToArray指向一个数组，这个数组内含三个元素。接着与*结合，即这个数组内含三个指针元素。最后与int结合，最终解析出ptrToArray是一个指向内含三个整型指针元素数组的指针。

四、数组指针数组

#include<iostream>
int main(int argc, char *argv[])
{
	int abc[2][3] = { 1,2,3,4,5,6 };
	int(*p[2])[3] = { &abc[0],&abc[1] };  //数组指针数组

	for (int i = 0; i < 2; ++i)
	{
		std::cout << "p[" << i << "]:" << p[i] << "\t&abc[" << i << "]:" << &abc[i] << '\n';
	}
	std::cout << std::endl;
	return 0;
}

分析：
int(*p[2])[3]：因为都在组合运算符()内，并且运算符[]的优先级高于运算符*，p先与[2]结合，说明p是一个内含两个元素的数组。再与*结合，即p是一个内含两个指针元素的数组。由于编译器从右向左解析，再与[3]结合，说明p是一个内含两个指向数组的指针元素的数组，最后再与int结合，最终p是一个内含有两个指向整型数组的指针元素的数组。

五、总结
要注意并且重视运算符优先级与结合性的运用。

参考
《C语言程序设计》（第3版）（谭浩强,清华大学出版社）
《C++程序设计教程》（第3版）（王珊珊，臧洌，张志航，机械工业出版社）
《C++ Primer Plus》（Six Edition）(Stephen Prata)
《C和指针》（Kenneth A. Reek)
广大CSDN社友们的文章