指针拾遗|||——指针数组、数组指针、函数指针、函数指针数组

指针拾遗|||——指针数组、数组指针、函数指针、函数指针数组

int *f[];//f: 指针数组
int (*f)[];//f: 数组指针

int (*f)();//f: 函数指针
int *(*f)();//f: 函数指针

int (*f[])();//f: 函数指针数组
int *(*f[])();//f: 函数指针数组

函数指针的两个例子如下：

eg1：int (*f)(int, float);
把 f 声明为一个函数指针，
它所指的函数接受两个参数: int型的值 和 float型的值；
返回一个整型值。

eg2:int *(*g[])(int, float);
把 g 声明为一个数组，
数组元素为 一个函数指针，
该函数指针所指的函数接受两个参数：int型的值 和 float型的值；
返回值为一个整型指针。

//复杂的数组声明
constexpr int size = 10;
int arr[size] = { 0,10,20,30,40,50,60,70,80,90 };
int arr2[size] = { 0,1,2,3,4,5,6,7,8,9 };
//一、ptrs是个指针数组：1、ptrs是个数组，2、数组包含10个元素，3、每个元素是一个指向int型整数对象的指针
int *ptrs[size] = { arr,arr2 };
//err：不允许使用引用的数组
//int &refs[10];
//二、Parray是个数组指针，指向一维数组的指针，也成行指针：1、Parray是个指针，2、指针指向一个数组，3、数组包含10个元素，4、每个元素都是int型整数对象
int(*Parray)[size] = &arr;
//三、arrRef是个数组引用，arrRef绑定了数组arr：1、arrRef是个引用，2、引用绑定的对象是个数组arr，3、数组包含10个元素，4、每个元素的类型是int型整数对象
int(&arrRef)[size] = arr;

void test10()
{
	//复杂的数组声明
	constexpr int size = 10;
	int arr[size] = { 0,10,20,30,40,50,60,70,80,90 };
	int arr2[size] = { 0,1,2,3,4,5,6,7,8,9 };
	int *ptrs[size] = { arr,arr2 };//ptrs是个指针数组：1、ptrs是个数组，2、数组包含10个元素，3、每个元素是一个指向int型整数对象的指针
	//int &refs[10];//err：不允许使用引用的数组
	int(*Parray)[size] = &arr;//Parray是个数组指针，指向一维数组的指针，也成行指针：1、Parray是个指针，2、指针指向一个数组，3、数组包含10个元素，4、每个元素都是int型整数对象
	int(&arrRef)[size] = arr;//arrRef是个数组引用，arrRef绑定了数组arr：1、arrRef是个引用，2、引用绑定的对象是个数组arr，3、数组包含10个元素，4、每个元素的类型是int型整数对象

	cout << "遍历指针数组" << endl;
	for (auto p = ptrs; p != ptrs + 2; ++p)
	{
		for (auto q = *p; q != *p + size; ++q)
		{
			cout << *q << "\t";
		}
		cout << endl;
	}
	cout << endl;

	cout << "使用数组指针，遍历数组" << endl;
	//for (int *p = Parray[0]; p != *Parray + size; ++p)//这也OK
	for (int *p = *Parray; p != *Parray + size; ++p)
	{
		cout << *p << "\t";
	}
	cout << endl;

	cout << "遍历数组引用" << endl;
	for (auto iter = begin(arrRef); iter != end(arrRef); ++iter)
	{
		cout << *iter << "\t";
	}
	cout << endl;
}