1、函数指针
数组名是指向第一个数组元素常量指针;同理,函数名也是指向函数的第一条指令的常量指针
int (*p)(int);//声明一个指针p,它指向一个函数,这个函数带有一个int型参数,并且返回值为int型
int fun(int i, int j)
{
return i + j;
}
int main()
{
//声明一个函数指针p
int (*p)(int, int);
//把函数fun的入口地址赋给函数指针p
p = fun;
//对函数指针传参并打印结果
cout<<p(1,2);
return 0;
}
2、函数指针数组
顾名思义,这个函数指针数组中每个元素都指向一个函数的入口,它和函数指针是一样的,只是数量上的差异
int(*p[3])(int ,int);//声明了一个有3个元素的函数指针数组,它的每一个元素都指向一个拥有两个int型参数并且返回类型为int的函数
float fun1(float i, float j)
{
return i + j;
}
float fun2(float i, float j)
{
return i - j;
}
float fun3(float i, float j)
{
return i * j;
}
float fun4(float i, float j)
{
return i / j;
}
int main()
{
//声明一个函数指针数组p
//可以像数组一样赋值
float (*p[4])(float, float)/* = {fun1, fun2, fun3, fun4}*/;
//把函数的入口地址赋给函数指针数组p
p[0] = fun1;
p[1] = fun2;
p[2] = fun3;
p[3] = fun4;
//对函数指针传参并打印结果
cout<<p[0](1,2)<<endl;
cout<<p[1](1,2)<<endl;
cout<<p[2](1,2)<<endl;
cout<<p[3](1,2)<<endl;
return 0;
}
3、函数指针作为参数
函数指针也可以作为函数的参数传递
float func(float(*p)(float, float), float i, float j);//函数func有三个参数,第一个参数是 一个函数指针,第二三个参数都是float类型元素,这个参数的返回值是一个float类型数据
float fun1(float i, float j)
{
return i + j;
}
float fun2(float i, float j)
{
return i - j;
}
float fun3(float i, float j)
{
return i * j;
}
float fun4(float i, float j)
{
return i / j;
}
float func(float(*p)(float, float), float i, float j)
{
return p(i, j);
}
int main()
{
float a = 3, b = 5;
float (*p)(float, float);
int n = 0;
cin>>n;
switch (n)
{
case 0:
{
p = fun1;
}break;
case 1:
{
p = fun2;
}break;
case 2:
{
p = fun3;
}break;
case 3:
default:
{
p = fun4;
}break;
}
cout<<func(p, a, b)<<endl;
return 0;
}
4、利用typedef简化函数指针
typedef float(*pF)(float, float);
float fun(float i, float j)
{
return i + j;
}
int main()
{
pF p;
p = fun;
cout<<p(1.2f, 3.3f)<<endl;
return 0;
}
5、类的函数指针
class A
{
public:
void fun()
{
cout<<"Hello World"<<endl;
}
};
int main()
{
//声明一个属于类A的函数指针pF
void(A::*pF)();
A *p = new A;
//将类的成员函数地址赋给函数指针pF
pF = &A::fun;
//对0象指针p通过函数指针pF访问成员函数
(p->*pF)();
delete p;
return 0;
}
6、类的函数指针数组
class A
{
public:
void fun()
{
cout<<"Hello";
}
void print()
{
cout<<" World"<<endl;
}
};
int main()
{
//声明一个指向类A的函数指针数组,并给每个数组元素赋值(数组元素的值就是类A的成员函数地址)
void(A::*pF[2])() = {&A::fun, &A::print};
A *p = new A;
for (int i = 0; i < 2; i++)
{
//通过pF访问类A的成员函数
(p->*pF[i])();
}
delete p;
return 0;
}