C/C++ 函数指针使用总结

一 函数指针介绍

函数指针指向某种特定类型,函数的类型由其参数及返回类型共同决定,与函数名无关。举例如下:

  1. int add(int nLeft,int nRight);//函数定义

该函数类型为int(int,int),要想声明一个指向该类函数的指针,只需用指针替换函数名即可

  1. int (*pf)(int,int);//未初始化

则pf可指向int(int,int)类型的函数。pf前面有*,说明pf是指针,右侧是形参列表,表示pf指向的是函数,左侧为int,说明pf指向的函数返回值为int。则pf可指向int(int,int)类型的函数。而add类型为int(int,int),则pf可指向add函数。

  1. pf = add;//通过赋值使得函数指针指向某具体函数

注意:*pf两端的括号必不可少,否则若为如下定义:

  1. int *pf(int,int);//此时pf是一个返回值为int*的函数,而非函数指针

二 标准C函数指针

 1函数指针的定义

1.1 普通函数指针定义

  1. int (*pf)(int,int);

1.2 使用typedef定义函数指针类型

  1. typedef int (*PF)(int,int);
  2. PF pf;//此时,为指向某种类型函数的函数指针类型,而不是具体指针,用它可定义具体指针</span>

 2函数指针的普通使用

  1. pf = add;
  2. pf(100,100);//与其指向的函数用法无异
  3. (*pf)(100,100);//此处*pf两端括号必不可少

注意:add类型必须与pf可指向的函数类型完全匹配

 3函数指针作为形参

  1. //第二个形参为函数类型,会自动转换为指向此类函数的指针
  2. Void fuc(int nValue,int pf(int,int));
  3. //等价的声明,显示的将形参定义为指向函数的指针
  4. Void fuc(int nValue,int (*pf)(int,int));
  5. Void fuc(int nValue,PF);

形参中有函数指针的函数调用,以fuc为例:

  1. pf = add;//pf是函数指针
  2. fuc(1,add);//add自动转换为函数指针
  3. fuc(1,pf);

 4返回指向函数的指针

4.1 使用typedef定义的函数指针类型作为返回参数

  1. PF fuc2(int);//PF为函数指针类型

4.2 直接定义函数指针作为返回参数

  1. int (*fuc2(int))(int,int);//显示定义

 说明:按照有内向外的顺序阅读此声明语句。fuc2有形参列表,则fuc2是一个函数,其形参为fuc2(int),fuc2前面有*,所以fuc2返回一个指针,指针本身也包含形参列表(int,int),因此指针指向函数,该函数的返回值为int.

总结:fuc2是一个函数,形参为(int),返回一个指向int(int,int)的函数指针。

二 C++函数指针

 1由于C++完全兼容C,则C中可用的函数指针用法皆可用于C++

2 C++其他函数(指针)定义方式及使用

2.1 typedef与decltype组合定义函数类型

  1. typedef decltype(add) add2;

decltype返回函数类型,add2是与add相同类型的函数,不同的是add2是类型,而非具体函数。

使用方法:

  1. add2* pf;//pf指向add类型的函数指针,未初始化

2.2 typedef与decltype组合定义函数指针类型

  1. typedef decltype(add)* PF2;//PF2与1.1PF意义相同
  1. PF2 pf;// pf指向int(int,int)类型的函数指针,未初始化

2.3 使用推断类型关键字auto定义函数类型和函数指针

  1. auto pf = add;//pf可认为是add的别名(个人理解)
  2. auto *pf = add;//pf为指向add的指针

3函数指针形参

  1. typedef decltype(add) add2;
  2. typedef decltype(add)* PF2;
  3. void fuc2 (add2 add);//函数类型形参,调用自动转换为函数指针
  4. void fuc2 (PF2 add);//函数指针类型形参,传入对应函数(指针)即可

说明:不论形参声明的是函数类型:void fuc2 (add2 add);还是函数指针类型void
fuc2 (PF2 add);都可作为函数指针形参声明,在参数传入时,若传入函数名,则将其自动转换为函数指针。

4  返回指向函数的指针

4.1 使用auto关键字

 auto fuc2(int)-> int(*)(int,int) //fuc2返回函数指针为int(*)(int,int) 

4.2 使用decltype关键字

  1. decltype(add)* fuc2(int)//明确知道返回哪个函数,可用decltype关键字推断其函数类型,

5 成员函数指针

5.1普通成员函数指针使用举例

  1. class A//定义类A
  2. {
  3. private:
  4. int add(int nLeft, int nRight)
  5. {
  6. return (nLeft + nRight);
  7. }
  8. public:
  9. void fuc()
  10. {
  11. printf("Hello  world\n");
  12. }
  13. };
  14. typedef void(A::*PF1)();//指针名前需加上类名限定
  15. PF1 pf1 = &A::fuc; //必须有&
  16. A a;//成员函数地址解引用必须附驻与某个对象地址,所以必须创建一个队形
  17. (a.*pf1)();//使用成员函数指针调用函数

5.2继承中的函数指针使用举例

  1. class A
  2. {
  3. public:
  4. void fuc()
  5. {
  6. printf("Hello fuc()\n");
  7. }
  8. void fuc2()
  9. {
  10. printf("Hello A::fuc2()\n");
  11. }
  12. };
  13. class B:public A
  14. {
  15. public:
  16. virtual void fuc2()
  17. {
  18. printf("Hello B::fuc2()\n");
  19. }
  20. };
  21. typedef void(A::*PF1)();
  22. typedef void(B::*PF2)();
  23. PF1 pf1 = &A::fuc;
  24. int main()
  25. {
  26. A a;
  27. B b;
  28. (a.*pf1)();  //调用A::fuc
  29. (b.*pf1)();   //调用A::fuc
  30. pf1 = &A::fuc2;
  31. (a.*pf1)();  //调用A::fuc2
  32. (b.*pf1)();  //调用A::fuc2
  33. PF2 pf2 = &A::fuc2;
  34. (b.*pf2)(); //调用A::fuc2
  35. }

6重载函数的指针

6.1 重载函数fuc

  1. Void fuc();
  2. Void fuc(int);

6.2 重载函数的函数指针

  1. void (*PF)(int) = fuc;//PF指向fuc(int)
  2. int(*pf2)(int) = fuc;//错误没有匹配的类型

注意:编译器通过指针类型决定选取那个函数,指针类型必须与重载函数中的一个精确匹配。

时间: 2024-10-29 06:02:20

C/C++ 函数指针使用总结的相关文章

单继承与多继承中的虚函数表和虚函数指针

首先,我们了解一下何为单继承,何为多继承?? 单继承:一个子类只有一个直接父类. 多继承:一个子类有两个或多个直接父类. 单继承中的虚函数表分析: 示例程序: #include <iostream> using namespace std; typedef void(*FUNC)(); class Base { public: virtual void func1() { cout << "Base::func1()" << endl; } virt

C#委托与C语言函数指针及函数指针数组

C#委托与C语言函数指针及函数指针数组 在使用C#时总会为委托而感到疑惑,但现在总新温习了一遍C语言后,才真正理解的委托. 其实委托就类似于C/C++里的函数指针,在函数传参时传递的是函数指针,在调用的时候通过指针访问这个函数. 在C语言中函数指针的申明如下: //可以理解为申明一个指着变量 Func ,它的类型是 返回Type(可以为 void )类型的参数,接收 (Type one,Type two,...)类型的//参数(可以不接受参数). Type *Func(Type one,Type

恼人的函数指针(一)

原文链接:http://www.cnblogs.com/AnnieKim/archive/2011/11/20/2255813.html 这篇是为了加深记忆所写.发现,很多知识若不经过反复的琢磨和动手实践,是很难记得住的. 1)  函数指针的初始化. 函数如下: int CompareString(const string& str1, const string& str2) { return str1.compare(str2); } 函数的初始化有两种方式: 第一种,也是最普遍的方式:

C++成员函数指针错误用法警示(成员函数指针与高性能的C++委托,三篇),附好多评论

今天做一个成绩管理系统的并发引擎,用Qt做的,仿照QtConcurrent搞了个模板基类.这里为了隐藏细节,隔离变化,把并发的东西全部包含在模板基类中.子类只需注册需要并发执行的入口函数即可在单独线程中执行.最终目标是,继承的业务逻辑类外部调用时有两个接口可选,调用syncRun同步执行:调用由引擎自动生成的asyncRun就异步执行.最终自动生成asyncRun的模板基类没能实现,主要原因是mingw对this处理的太有问题了!!原本以为编译器问题,后来才知道成员函数指针和this指针如此特殊

深入浅出剖析C语言函数指针与回调函数(二)

上一篇博文的地址: http://blog.csdn.net/morixinguan/article/details/65494239 这节,我们来看看函数指针与回调函数在Linux内核中的应用. 从上节我们了解到,函数指针和回调函数在开发者和用户之间的一个例子,那么这节,我将引用Linux内核中文件操作结构体来详细的说明. 我们首先来看到这个结构体,这段代码位于linux内核的include/linux/fs.h中,由于代码众多,我只截取几个最基本的例子: File_operations文件操

C语言函数、函数指针解析

函数.函数指针的理解: 函数的定义: void myfunc(void) { } 函数的声明 void myfunc(void); 函数指针的定义.初始化.赋值: 定义:void (*funcp)(void); 初始化: void (*funcp)(void) = &myfunc; 赋值 void (*funcp)(void); funcp = &myfunc; 函数调用:(*funcp)(); funcp(); 也可以这样赋值:void (*funcp)(void); funcp = m

6.7 函数指针

函数指针重载:参数类型要匹配,指针类型必须精确匹配 使用decltype作用于某个函数时,要显示加上*以表示我们需要返回指针,而非函数本身 int func(int a, int b); using pFunc1 = decltype(func) *;typedef decltype(func) *pFunc2;using pFunc3 = int (*)(int a, int b);using pFunc4 = int(int a, int b);typedef int(*pFunc5)(in

数组指针、指针数组、函数指针、指针函数 -----笔记

1.数组的四种访问方式 定义数组 a[]; 指针 *p 指向数组a; (1) 利用数组的下表进行访问 a[i]; (2) 数组名+地址的偏移量i *(a+i) (3) 利用指针 p 进行下表访问 p[i] (4) 指针p + 地址的偏移量i *(p+i) 一维数组数组名:相当于一个单指针 2. 数组指针(指针)     指针数组(数组) 函数指针(指针)     指针函数(函数)    -------->只看后边两个字就能够区分是指针还是数组或函数 _______________________

成员函数指针和指向静态成员函数的指针

#include <iostream> using namespace std; class Student{ public:     Student(const string& name):m_name(name){}     void who(void){         cout << m_name << endl;     }     string m_name;     static int s_add(int a,int b){         re

【转】 指针函数与函数指针的区别

一. 在学习arm过程中发现这“指针函数”与“函数指针”容易搞错,所以今天,我自己想一次把它搞清楚,找了一些资料,首先它们之间的定义: 1.指针函数是指带指针的函数,即本质是一个函数.函数返回类型是某一类型的指针 类型标识符    *函数名(参数表) int *f(x,y); 首先它是一个函数,只不过这个函数的返回值是一个地址值.函数返回值必须用同类型的指针变量来接受,也就是说,指针函数一定有函数返回值,而且,在主调函数中,函数返回值必须赋给同类型的指针变量. 表示: float *fun();