数组指针,指针数组,函数指针,指针函数的分析
一:数组指针
数组指针(也称行指针)定义:int(*p)[n],是指针,指向数组的指针
()的优先级高,首先说明p是一个指针,指向一个整形的一维数组,这个一维数组的长度为n,也可以说是p的步长,也就是说,当p执行p+1操作时,p要跨过n个整形数据的长度。
int main() {
int a[5] = { 1,2,3,4,5 };
int(*p)[5];
//把数组a的地址赋给p,则p为数组a的地址,*p表示a本身
p = &a;
printf("%p\n", a);//输出数组名,一般用首元素的地址来表示一个数组,则输出首元素的地址
printf("%p\n", p);//p为数组a的地址,则输出数组a的地址
printf("%p\n", *p);//*p为数组a本身,一般用首元素的地址来标识数组
printf("%p\n", &a[0]);//输出数组a首元素的地址
printf("%p\n", p[0]);//输出数组a首元素的地址
printf("%d\n", **p);//输出数组a首元素的值
printf("%d\n", a[0]);//输出数组a首元素的值
printf("%d\n", *p[0]);//输出数组a首元素的值
system("pause");
return 0;
}
如果要将一个二维数组赋给指针,应该这样赋值:
int a[3][4];
int (*p)[4] //该语句是定义一个数组指针,指向含4个元素的一维数组
p=a;//将该二位是数组的首地址赋给p,也就是a[0][0]
p++;//跨过a[0][]指向a[1][];
二:指针数组
指针数组 定义:int *p[n]
[]的优先级高,与p结合形成一个数组,再由int *说明这是一个整形指针,这里执行p+1是错误的,这样赋值也是错误的。
int main() {
int a = 1;
int b = 2;
int* p[2];
p[0] = &a;
p[1] = &b;
printf("%p\n", p[0]);
printf("%p\n", &a);
printf("%p\n", p[1]);
printf("%p\n", &b);
printf("%d\n", *p[0]);
printf("%d\n", *p[1]);
system("pause");
return 0;
}
如要将二维数组赋给一指针数组:
int *p[3];
int a[3][4];
for(i=0;i<3;i++)
p[i]=a[i];
这里int *p[3] 表示一个一维数组内存放着三个指针变量,分别是p[0]、p[1]、p[2]
所以要分别赋值。
数组指针是一个指针变量,占有内存中一个指针的存储空间
指针数组是多个指针变量,以数组的形式存储在内存中,占有多个指针的存储空间
int main() {
/*定义一个二维数组
0 1 2
3 4 5
输出第一行第二列的值:5*/
int a[2][3] = { {0,1,2},{3,4,5} };
int(*p)[3];//数组指针,指向含有3个元素的一维数组
int* q[2];//指针数组,一个数组内存中存放两个指针变量
p = a;
q[0] = a[0];
q[1] = a[1];
printf("%d\n", a[1][2]);
printf("%d\n", *(p[1] + 2));
printf("%d\n", *(*(p + 1) + 2));
printf("%d\n", (*(p + 1))[2]);
printf("%d\n", p[1][2]);
printf("%d\n", *(q[1] + 2));
printf("%d\n", *(*(q + 1) + 2));
printf("%d\n", *(q + 1)[2]);
printf("%d\n", q[1][2]);
system("pause");
return 0;
}
三:函数指针
函数具有可赋值给指针的内存地址,一个函数的函数名称就是一个指针,它指向函数的代码。也是调用函数的地址。函数的调用可以通过函数名,也可以通过指向函数的指针来调用,函数指针还允许将函数作为变元传递给其他函数。
我们知道数组名代表数组首元素的地址,同样,函数名代表函数的地址。
函数指针原型:
类型(*指针变量名)(参数列表)
例如:
int(*fun)(int int)
注意:函数指针,首先它是一个指针,它指向函数的地址
int Max(int a, int b) {
return a > b ? a : b;
}
int Min(int a, int b) {
return a < b ? a : b;
}
//声明指针函数
int(*fun)(int, int);
int main() {
int i = 10;
int j = 20;
fun = &Max;//函数指针赋值
cout << fun(i, j) << endl;
fun = &Min;
cout << fun(i, j) << endl;
system("pause");
return 0;
}
int Max(int a, int b) {
return a > b ? a : b;
}
int(*fun)(int, int);
int getMax(int a, int b, int(*fun)(int, int)) {
return fun(a, b);
}
int main() {
int i = 10;
int j = 20;
cout << getMax(i, j, Max)<<endl;
system("pause");
return 0;
}
函数指针数组
函数指针数组,首先它是一个数组,数组元素是函数的地址。即把函数的地址保存在数组里。
int add(int a, int b) {
return a + b;
}
int sub(int a, int b) {
return a - b;
}
int mul(int a, int b) {
return a * b;
}
int main() {
int x, y;
int input = 0;
int ret=0;
int(*p[4])(int x, int y) = { 0,add,sub,mul };
cout << "选择操作(0~3)" << endl;
cin >> input;
cout << "请输入两个数" << endl;
cin >>x>>y;
ret = (*p[input])(x, y);
cout << ret << endl;
system("pause");
return 0;
}
typedef函数指针
typedef是定义一种新类型,如下:
typedef int (*pFun)(int, int);//定义函数指针别名
int Max(int a, int b) {
return a > b ? a : b;
}
int main() {
pFun fun; //定义函数指针变量
fun = Max; //函数指针变量赋值
cout << (*fun)(10, 20) << endl;
system("pause");
return 0;
}
#include<iostream>
using namespace std;
typedef int(*FP_CALC)(int, int);
int add(int a, int b) {
return a + b;
}
int sub(int a, int b) {
return a - b;
}
int mul(int a, int b) {
return a * b;
}
int div(int a, int b) {
return a / b;
}
//根据操作符返回相应函数的地址
FP_CALC get_funAddr(char op) {
switch (op) {
case'+':
return add;
case'-':
return sub;
case'*':
return mul;
/*case'/':
return div;*/
default:
return NULL;
}
return NULL;
}
int calc(int a, int b, char op) {
FP_CALC fp = get_funAddr(op);
if (fp) {
return (*fp)(a, b);
}
else {
return -1;
}
}
int main() {
int a = 100, b = 20;
cout << calc(a, b, '+')<<endl;
cout << calc(a, b, '-')<<endl;
cout << calc(a, b, '*')<<endl;
cout << calc(a, b, '/')<<endl;
return 0;
}
注:函数指针的值表示程序将要跳转的地址,指针的类型表示程序的调用方式。
四:指针函数
指针函数本质是一个函数,该函数的返回值是一个指针。
声明格式:类型标识符*函数名(参数列表)
普通函数声明:
int fun(int x,int y)
指针函数声明:
int *fun(int x,int y)
其返回值是一个int类型的指针
//指针函数的声明
int* pfun(int* arr, int n);
//指针函数的定义
int* pfun(int* arr, int n) {
int* p = arr;
return p;
}
int main() {
int arr[] = { 0,1,2,3 };
int size = sizeof(arr) / sizeof(arr[0]);
int* p;
int i;
//指针函数的调用
p = pfun(arr, size);
for (i = 0;i < size;i++) {
cout << *(p + i) << endl;
}
return 0;
}
主函数中,把一个数组的首地址与数组长度作为实参传给指针函数pfun里,把指针函数的返回值(即指向数组的指针)赋给整形指针p。最后用指针p来遍历数组元素并打印输出。