本文目录
C语言函数指针怎么用
有函数: int fun(int a,int b);
要定义指向该函数的指针
对比指向 int a; 的指针
int *p; p = &a
p的定义是怎么来的？
首先要保证p是一个指针类型
写下(*p)，
然后，考虑下p的基类型，
p的基类型就是变量a的类型int
将int 放在(*p)前面就行了
int (*p);
括号可以省略，就成了 int *p;
同理
想要实现 pf = &fun
(*pf) 将pf定义为一个指针，
将fun的类型作为pf的基类型
fun相当于一个 int (int a,int b)类型的量
int (int a,int b) (*pf);
基类型中有圆括号和中括号要后移
int (*pf)(int a,int b) ;//括号不能省略
pf = &fun
调用时
(*pf)(3,4); pf(3,4)都可以
指向函数的指针的用法
double
(*ptr)(double
x);
这里参数是表示该指针指向的函数应该是这样一类，它的参数是一个双精度类型的，返回值是一个双精度类型的，就像第2行的square函数，它的赋值在第5行
ptr(6.6)，表示用函数参数6.6，调用ptr指向的函数
如何使用函数指针指向几个函数
如果是在C#中的话,用委托进行多播,既可以同时指向多个函数,触发该事件时，同时调用所有函数。事件是该委托的一个特例。
如果是C语言的话，函数指针可以指向任何签名和函数指针定义一致的任何函数。签名指的是参数列表和参数类型以及返回参数类型，必须严格一致。
函数指针如何定义
用函数指针变量调用函数
可以用指针变量指向整形变量、字符串、数组、结构体、也可以指向一个函数。一个函数在编译时被分配一个入口地址。这个入口地址就称为函数指针。可以用一个指针变量指向函数，然后通过该指针变量调用此函数。
函数指针是一种在C、C++、D语言、其他类 C 语言和Fortran 2003中的指针。函数指针可以像一般函数一样，用于调用函数、传递参数。在如 C 这样的语言中，通过提供一个简单的选取、执行函数的方法，函数指针可以简化代码。
函数指针只能指向具有特定特征的函数。因而所有被同一指针运用的函数必须具有相同的参数和返回类型。
c++的函数指针是怎么用的呀
函数指针，即指向函数的指针。
1. 定义
每一个函数都占用一段内存单元，它们有一个起始地址，指向函数入口地址的指针称为函数指针。
2. 语法
指向函数的指针变量的一般定义形式为：
数据类型 (*指针变量名)(参数表);
3. 说明
1） 函数指针的定义形式中的数据类型是指函数的返回值的类型。
2） 区分下面两个语句：
int (*p)(int a, int b); //p是一个指向函数的指针变量，所指函数的返回值类型为整型
int *p(int a, int b); //p是函数名，此函数的返回值类型为整型指针
3） 指向函数的指针变量不是固定指向哪一个函数的，而只是表示定义了一个这样类型的变量，它是专门用来存放函数的入口地址的；在程序中把哪一个函数的地址赋给它，它就指向哪一个函数。
4） 在给函数指针变量赋值时，只需给出函数名，而不必给出参数。
如函数max的原型为：int max(int x, int y); 指针p的定义为：int (*p)(int a, int b); 则p = max;的作用是将函数max的入口地址赋给指针变量p。这时，p就是指向函数max的指针变量，也就是p和max都指向函数的开头。
5） 在一个程序中，指针变量p可以先后指向不同的函数，但一个函数不能赋给一个不一致的函数指针（即不能让一个函数指针指向与其类型不一致的函数）。
如有如下的函数：int fn1(int x, int y); int fn2(int x);
定义如下的函数指针：int (*p1)(int a, int b); int (*p2)(int a);
则
p1 = fn1; //正确
p2 = fn2; //正确
p1 = fn2; //产生编译错误
6） 定义了一个函数指针并让它指向了一个函数后，对函数的调用可以通过函数名调用，也可以通过函数指针调用（即用指向函数的指针变量调用）。
如语句：c = (*p)(a, b); //表示调用由p指向的函数(max)，实参为a,b，函数调用结束后得到的函数值赋给c。
7） 函数指针只能指向函数的入口处，而不可能指向函数中间的某一条指令。不能用*(p+1)来表示函数的下一条指令。
8） 函数指针变量常用的用途之一是把指针作为参数传递到其他函数
实例：
#include 《iostream》
using namespace std;
#include 《conio.h》
int max(int x, int y); //求最大数
int min(int x, int y); //求最小数
int add(int x, int y); //求和
void process(int i, int j, int (*p)(int a, int b)); //应用函数指针
int main()
{
int x, y;
cin》》x》》y;
cout《《“Max is: “;
process(x, y, max);
cout《《“Min is: “;
process(x, y, min);
cout《《“Add is: “;
process(x, y, add);
getch();
return 0;
}
int max(int x, int y)
{
return x 》 y ? x : y;
}
int min(int x, int y)
{
return x 》 y ? y : x;
}
int add(int x, int y)
{
return x + y;
}
void process(int i, int j, int (*p)(int a, int b))
{
cout《《p(i, j)《《endl;
}
函数指针的几种用法
什么是函数指针?函数指针指向的是特殊的数据类型，函数的类型是由其返回的数据类型和其参数列表共同决定的，而函数的名称则不是其类型的一部分。 用typedef定义函数指针类型// 定义函数指针类型cmpFuntypedefint (*cmpFun)(constint&, constint&); (3)这样，cmpFun就成了一种数据类型，可以用它来声明和定义形如(1)式中的pf那样的函数指针，比如：cmpFun pf = 0;cmpFun pf = someFunction; 举个例子来说明一下：#include《iostream》#include《string》usingnamespace std; // 定义函数指针pfint (*pf)(constint&, constint&); // 定义函数指针类型cmpFuntypedefint (*cmpFun)(constint&, constint&); // 具体函数int intCompare(constint& aInt, constint& bInt){ if(aInt == bInt) return 0; if(aInt 》 bInt) { return 1; } else { return -1; }} int main(void){ int aInt = 1; int bInt = 2; pf = intCompare; // pf = &stringCompare // 和上面一句是完全一样的 // 使用pf if(pf(aInt, bInt) == 0) { cout 《《 “two integers are equal“ 《《 “.“ 《《 endl; } elseif(pf(aInt, bInt) 》 0) { cout 《《 aInt 《《 “ is greater than “ 《《 bInt 《《 “.“ 《《 endl; } else { cout 《《 aInt 《《 “ is less than “ 《《 bInt 《《 “.“ 《《 endl; } cout 《《 “------------------------“ 《《 endl; // 用函数指针类型cmpFun声明并初始化一个函数指针pf2 cmpFun pf2 = intCompare; // 使用pf2 if(pf2(aInt, bInt) == 0) { cout 《《 “two integers are equal“ 《《 “.“ 《《 endl; } elseif(pf(aInt, bInt) 》 0) { cout 《《 aInt 《《 “ is greater than “ 《《 bInt 《《 “.“ 《《 endl; } else { cout 《《 aInt 《《 “ is less than “ 《《 bInt 《《 “.“ 《《 endl; } return 0;} 函数指针作为参数函数指针可以作为一个函数的参数，如下两种办法可以做到这一点：(a) int plusFun(int&, int&, int (constint&, constint&));(b) int plusFun(int&, int(*)(constint&, constint&));以上两个方式做到的是类似的事情：(a)中的plusFun函数的第三个参数就是一个函数指针， (b)中的第二个参数也是一个函数指针。(a)中的plusFun定义如下：//函数指针作为参数：错误的做法//int plusFun(int& aInt, int& bInt, int paf(const int& cInt, const int& dInt))//{//// return aInt + bInt + paf(cInt, dInt);//} //函数指针作为参数：正确的做法int plusFun(int& aInt, int& bInt, int paf(constint &, constint &)){ int cInt = 2; int dInt = 1; return aInt + bInt + paf(cInt, dInt);} 调用plusFun的代码：…pf = intCompare;…// 函数指针作为参数int aaInt = 3;int bbInt = 4;cout 《《 plusFun(aaInt, bbInt, pf) 《《 endl; (b)中的plusFun定义如下：//函数指针作为参数：错误的做法//int plusFun(int& aInt, int(*paf2)(const int& bInt, const int& cInt))//{// return aInt + paf2(bInt, cInt);//} //函数指针作为参数：正确的做法int plusFun(int& aInt, int(*paf2)(constint&, constint&)){ int bInt = 1; int cInt = 2; return aInt + paf2(bInt, cInt);} 调用plusFun的代码：…cmpFun pf2 = intCompare;…// 函数指针作为参数int aaInt = 3;cout 《《 plusFun(aaInt, pf2) 《《 endl; 函数指针作为返回值一个函数的返回值可以是一个函数指针，这个声明形式写起来有点麻烦：// 函数指针作为返回值int (*retFunPointer(int))(constint&, constint&);上面的声明的含义：a) retFunPointer是一个函数，该函数有一个int类型的参数；b) retFunPointer返回值是一个函数指针，它指向的是带有两个const int&类型参数，且返回类型为int的函数。 retFunPointer的定义：// 函数指针为返回值int (*retFunPointer(int aInt))(constint&, constint&){ cout 《《 aInt 《《 endl; // pf已经在前面定义过了 return pf;} 调用代码示例：// 函数指针作为返回值，retFunPointer返回一个cmpFun类型的函数指针cmpFun pf3 = retFunPointer(aaInt);int result = pf3(aaInt, bbInt);cout 《《 result 《《 endl; 包含上面所有情况的完整代码#include《iostream》#include《string》usingnamespace std; // 定义函数指针pfint (*pf)(constint&, constint&); // 定义函数指针类型cmpFuntypedefint (*cmpFun)(constint&, constint&); // 函数指针作为参数int plusFun(int&, int(constint&, constint&));int plusFun(int&, int(*)(constint&, constint&)); // 函数指针作为返回值int (*retFunPointer(int))(constint&, constint&); // 具体函数int intCompare(constint& aInt, constint& bInt){ if(aInt == bInt) return 0; if(aInt 》 bInt) { return 1; } else { return -1; }} //函数指针作为参数：错误的做法//int plusFun(int& aInt, int& bInt, int paf(const int& cInt, const int& dInt))//{//// return aInt + bInt + paf(cInt, dInt);//} //函数指针作为参数：正确的做法int plusFun(int& aInt, int& bInt, int paf(constint &, constint &)){ int cInt = 2; int dInt = 1; return aInt + bInt + paf(cInt, dInt);} //函数指针作为参数：错误的做法//int plusFun(int& aInt, int(*paf2)(const int& bInt, const int& cInt))//{// return aInt + paf2(bInt, cInt);//} //函数指针作为参数：正确的做法int plusFun(int& aInt, int(*paf2)(constint&, constint&)){ int bInt = 1; int cInt = 2; return aInt + paf2(bInt, cInt);} // 函数指针为返回值int (*retFunPointer(int aInt))(constint&, constint&)《/
如何定义指向函数的指针
一、定义一个函数指针的方法如下：
返回值类型 （* 指针变量名）（[形参列表]）;
1、int func(int x); /* 声明一个函数 */
2、int (*f) (int x); /* 声明一个函数指针 */
3、f=func; /* 将func函数的首地址赋给指针f */
二、函数指针的用法：
函数指针的应用：（*指针变量名）（参数列表）
如：int c=(*ptr)(a,b);/* 函数指针 的使用*/
在C语言中，函数本身不是变量，但是可以定义指向函数的指针，也称作函数指针，函数指针指向函数的入口地址。这种类型的指针可以被赋值、存放在数组中、传递给函数以及作为函数的返回值等等。
扩展资料：
指针函数和函数指针的区别：
1、这两个概念都是简称，指针函数是指返回值是指针的函数，即本质是一个函数。我们知道函数都有返回类型（如果不返回值，则为无值型），只不过指针函数返回类型是某一类型的指针。
2、返回指针的函数的用途十分广泛。事实上，每一个函数，即使它不带有返回某种类型的指针，它本身都有一个入口地址，该地址相当于一个指针。比如函数返回一个整型值，实际上也相当于返回一个指针变量的值，不过这时的变量是函数本身而已，而整个函数相当于一个“变量”。
参考资料来源：百度百科-指针
参考资料来源：百度百科-函数指针
C语言中函数指针用法
在C语言中，指针被广泛使用，而函数指针是最为高级的用法之一，也是容易疑惑的地方之一。看下面这段代码：#include 《stdio.h》void F(int a, int* output)
{
printf(“a = %d\n“, a);
*output = a + 1;
}typedef void (*FUNC)();int main()
{
FUNC f = F;
int ret = 0;
f(3, &ret);printf(“ret = %d\n“, ret);
return 0;
}上面看出 FUNC 的类型是与F的类型不匹配的，这样可以通过编译吗？答案是： 可以的。由于在C语言中编译函数的时候，是仅仅将其函数名作为该函数的
唯一标识，为其分配相应地址。所以虽然FUNC 与 F的类型不一致，但是对于编译器看来
都是两个地址，是无所谓的。用上面的特点，可以写出非常通用的函数指针类型，typedef int (*FUNC)(); 这里之所有要有返回值，是用来标识该函数是否执行成功的错误代码标志。 随说做了有一段时间的C了,但尽然没有搞明白函数指针的用法,见到了也没有好好研究,今天终于有时间了,在网上搜了一下,终于弄懂了.原来就是定义了一个指针变量,只不过形式有点怪罢了.其实还是当成指针用就行了!一般有两种用法:1定义函数指针int (*functionPoint)(int, int)----这只是定义了一个指向函数的指针int a(int a,int b)----------------这是与之相符的函数原型void main()-----------------------使用{ functionPoint = a;------------先赋值 functionPoint(1,2);----------调用
}2用typedef定义使用typedef int (*functionPoint)(int,int);----------定义了一种类型名为functionPoint的指针int a(int a, int b)-----------------------------函数原型void main(){ functionPoint fun;---------------------------定义指针 fun = a;-------------------------------------赋值 fun(1,2);---------------------------------使用
}函数就是这个函数的指针.
c语言中指针怎么使用
1、使用场景
使用指针时，必须将它指向一个变量的地址或者为它分配空间方能使用，如下所示：
#include《stdio.h》
#include 《stdlib.h》
int main(int argc, char const *argv)
{
int a={0,1,2,3,4};
int *b,*d;
int c=2;
int *e=a; //e指向a数组首地址
//*b=2; 无法直接初始化
//printf(“%d\n“, *b);
e=e+2; //移动两个地址单元
d=&c; //d指向c的地址来表示值
c=4; //修改原c变量的值，d指针的值会发生改变
b=(int *)malloc(sizeof(int));//为b分配一个int型空间来直接存储值
*b=2;//分配空间后可以直接赋值了
printf(“this is e,b,c,d :%d %d %d %d\n“,*e,*b,c,*d);
2、类型说明
（1）int *a :表示一个指向int型变量的指针，指向的是变量的地址单元
（2）char *b:表示一个指向char变量的指针
*a表示的是这个指针指向地址的值，a为此指针本身的地址，这点要明确，一般用*(a+1)、*(a+2)来表示值，如：
int nums={0,1,2,3,4};
int *a=nums;
printf(“%d %d %p\n“,*a,*(a+1),a);
扩展资料：
指针的运算
指针指向变量地址，若原变量的内容发生了变化，它本身也会发生变化，指针之间的运算一般为值运算和地址运算
（1）值运算：直接通过*运算方式，像a+*(a+1),结果为第一个元素与第二个元素相加。
int nums={0,1,2,3,4};
int *a=nums;
（2）地址运算：通过a+i的方式.指针会指向a的下i个地址。
int nums={0,1,2,3,4};
int *a=nums;
a=a+2;
printf(“%d\n“,*a);
结果输出2。
