c++函数指针浅谈

        C++函数指针是指向一个函数的指针变量。函数指针可以像普通函数一样调用，也可以作为参数传递给其他函数。

定义

函数指针是指向函数的指针变量。通常我们说的指针变量是指向一个整型、字符型或数组等变量，而函数指针是指向函数。函数指针可以像一般函数一样，用于调用函数、传递参数。指针(pointer)是"指向(point to)"另外一种类型的复合类型。

函数指针变量的声明：

typedef int (*fun_ptr)(int,int); // 声明一个指向同样参数、返回值的函数指针类型

定义指针类型的方法将声明符写成*d的形式，其中d是变量名。在一条语句内声明多个指针对象必须每个变量名前都有*。

        项目中经常运用函数指针，常作为回调方式，一来代码整洁，逻辑调用清晰；二来对比Qt的模式（如Qt信号槽），性能更优

用法

分成员函数指针和全局函数指针

typedef int (*funcPtr)(int);
typedef int (FunctionPtrTest::*innerfuncPtr)(int);
class FunctionPtrTest
{
public:
    int callFunction(funcPtr fun,int);
    int callFunction(innerfuncPtr fun,int);
    int callTest(int (FunctionPtrTest::*ptr)(int),int);
    int funTest(int);
    static int funTest2(int);
    static void funStaticTest(int,const QString&);
};

int FunctionPtrTest::callFunction(funcPtr fun, int num)
{
    return fun(num);
}

int FunctionPtrTest::callFunction(innerfuncPtr fun, int num)
{
    return (this->*fun)(num);
}

int FunctionPtrTest::callTest(int (FunctionPtrTest::*ptr)(int), int num)
{
    return (this->*ptr)(num);
}


int FunctionPtrTest::funTest(int num)
{
    qDebug() << __FUNCTION__ << num;
    return ++num;
}

int FunctionPtrTest::funTest2(int num)
{
    qDebug() << __FUNCTION__ << num;
    return --num;
}

void FunctionPtrTest::funStaticTest(int num, const QString &str)
{
    qDebug() << __FUNCTION__ << num << str;
}

函数调用

/m_functionPtrTest为FunctionPtrTest实例
int data = 100;
innerfuncPtr fun = &FunctionPtrTest::funTest;
data = m_functionPtrTest->callFunction(fun,data);

funcPtr fun2 = &FunctionPtrTest::funTest2;
data = m_functionPtrTest->callFunction(fun2,data);

在上面的示例中，我们定义了一个名为 innerfuncPtr的函数指针变量，将 funTest函数的地址赋值给它，然后使用 m_functionPtrTest调用函数的方式传入函数指针

其中callFunction分别调用全局函数指针和成员函数指针用例

下面讲讲相对高级用法，这里只是举例通俗的用法，函数调度方式

class PFuncParamBase
{
public:
    virtual ~PFuncParamBase(){}
    virtual void start(){}
};

template<class Class>
class PFuncParam : public PFuncParamBase
{
public:
    PFuncParam(Class* o,void (Class::*p)()):
        obj(o),pf(p){}
    virtual void start();

private:
    Class* obj;
    typedef void (Class::*pF)();
    pF pf;

};

template<class Class>
void PFuncParam<Class>::start()
{
    (obj->*pf)();
}

class Test1
{
public:
    void doFunc()
    {
        qDebug() << __FUNCTION__;
    }
};

class Test2
{
public:
    void doFunc()
    {
        qDebug()  << __FUNCTION__;
    }
};

int main(int argc, char *argv[])
{

   Test1 t;
   Test2 t2;
   QList<PFuncParamBase*> lts;
   lts.push_back( new PFuncParam<Test1>(&t,&Test1::doFunc) );
   lts.push_back( new PFuncParam<Test2>(&t2,&Test2::doFunc) );
   for(int i = 0 ;i<lts.count();++i)
   {
       lts.at(i)->start();
       delete  lts.at(i);
   }
   return 0;
}

上面通过保持对象的成员函数指针即对象，常用于注册对象的函数回调，基本原理类似，写法比较简单，但基本原理都是基于此变化，不懂之处欢迎留言探讨