C/C++函数指针，指针函数的用法，用处

 先看函数指针

int func2(int x); 　　 /* 声明一个函数 */

int (*q2) (int x); 　　/* 声明一个函数指针 */

q2=func2; 　　　　   /* 将func函数的首地址赋给指针f */

int c=(*q2)(3);　　　//3可以为任意实参

 

上面4句基本说明了函数指针的用法：

函数指针是指向函数的指针，确切的说，是指向特定类型函数的指针（函数与函数指针 类型要匹配）

函数指针用来保存函数首地址，即可以通过该指针访问函数。函数指针 相当于取别名。

函数指针可以指向一类函数，而不是一个函数，即 可以重新赋值。（见例2）

 

函数指针不难，只要记住上面黑体字就差不多了，附上两个简单的例子

例1：

#include<stdio.h>
int max(int x,int y){ return(x>y?x:y); }
void main()
{
  int (*ptr)(int, int);  //定义一个指针
  int a,b,c;
  ptr=max;
  scanf("%d%d",&a,&b);
  c=(*ptr)(a,b);
  printf("a=%d,b=%d,max=%d",a,b,c);
}

例2：

#include<stdio.h>
void FileFunc()
{
  printf("FileFunc\n");
}
void EditFunc()
{
  printf("EditFunc\n");
}
void main()
{
  typedef void (*funcp)();
  funcp pfun= FileFunc;
  pfun();
  pfun = EditFunc;
  pfun();
}

再看指针函数：

int *func(int x);/* 声明一个指针函数 */

int *q; /* 声明一个指针 */

q=func(3);//3可以为任意实参

 

上面三句基本说明了指针函数：

指针函数是返回值为指针的函数，所以我们在main()中调用它时可以用一个同类型的指针来接收。

指针函数可以用来解决众多问题，如返回多个值的问题。（见"函数返回多个值的方法"那篇文章）

指针函数比经常更经常用到，一定要学会用

 

指针函数逻辑简单，结构清新，功能强大，质量好，效率高，堪比极品中的凤姐，胜过。。。（求下联），反正不学会真是损失。

 

例3也是百度来的，个人觉得很经典，涉及到了指针，数组指针，指针函数，二维数组的赋值，函数返回多个值，数组指针的自增与指针自增的区别。。。众多知识。看懂这个基本指针这一块差不多了。

 

例3：

其实跟函数指针无关，考虑

float (*p)[4]; // pointer to an array of 4 floats

float *p[4];   // an array with 4 pointers pointed to float

#include<iostream>
using namespace std;
int main()
{
  float *find(float (*p)[4],int m);//查询序号为m的学生的四门课程的成绩
  float score[][4]={{50,51,52,55},{70,70,40,80},{77,99,88,67}};//定义成绩数组，第一维可以为变量
  float *pf=NULL;//定义一个指针时一定要初始化
  int i,m;

  //cout<<"请输入您想查询的学生的序号:";

  cin>>m;
  pf=find(score,m);//返回为一维数组指针，指向一个学生成绩
  for(i=0;i<4;i++)
    cout<<*(pf+i)<<" ";
  cout<<endl;
  return 0;
}
float *find(float (*p)[4],int m)
{
  float *pf=NULL;
  pf=*(p+m);//p是指向二维数组的指针，加*取一维数组的指针
  return pf;
}

例4：

对象可以调用自己的析构函数：

也可以调用自己的构造函数：

再演示一下指向成员变量的指针：

#include <iostream>
#include <string>
#include <stack>
using namespace std;
class A {
public:
  int x;
  char y;
  int z;
  char p;
};
class Base {
public:
  virtual void f() { cout << "Base::f" << endl; }
  virtual void g() { cout << "Base::g" << endl; }
  virtual void h() { cout << "Base::h" << endl; }
  void f1() {printf("f1\n");}
  void f2() {printf("f2\n");}
  char c;
};
int max(int x,int y){ return(x>y?x:y); } 
int main()
{
  A a;
  int res = (reinterpret_cast<int>(&a.p) - reinterpret_cast<int>(&a)) / sizeof(a.p); 

  Base b;
  int x = sizeof(b);


  //cout << "虚函数表地址：" << (int*)(&b) << endl;
  //cout << "虚函数表 — 第一个函数地址：" << (int*)*(int*)(&b) << endl;
  //pFun = (Fun)*((int*)*(int*)(&b));
  //pFun();

  typedef void(Base::*Fun)(void);
  void (Base::*Fun2)(void);

  Fun pFun = NULL;
  Fun2 = &Base::f1;

  Fun p1 = &Base::f1;
  Fun p2 = &Base::f2;
  printf("%#p\n",p1);   //使用cout << p1 << endl;只输出1，cout函数的问题。。。。
  b.~Base();
  b.f1();
  b.Base::Base();

  return 0;
}

来自于：

http://www.cnblogs.com/anwcq/p/C_zhizhenhanshu.html