类成员函数作为函数指针

我有一个类，它的一个成员函数实际上是一个函数指针。这样用户就可以重写这个函数的功能。不幸的是，我在运行这个函数时遇到了一些困难。我用g++来编译。

代码如下:

    #include <iostream>
    using namespace std;
    double fcn_mod(const double &phit){
        return 1.2+phit;
    }
    class Object{
        public:
            Object() {
                fcn_ptr = (double (*)(const double &)) &Object::fcn_default;
            }
            double (*fcn_ptr)(const double &) = NULL;
        private:
            double fcn_default(const double &phit){
                return 3.2+phit;
            }
    };

    int main(){
        Object test1,test2;
        cout << (test1.*fcn_ptr)(2) << endl; // can not compile here
        test2.fcn_ptr = &fcn_mod;
        cout << (test2.*fcn_ptr)(2) << endl; // and here
        cout << "test" << endl;
    }

错误信息是:

    erreur: ‘fcn_ptr’ was not declared in this scope

+++++ UPDATE 1 +++++

考虑到注释，这里是一个更简洁的版本:

    #include <iostream>
    using namespace std;
    double fcn_mod(const double &phit){
        return 1.2+phit;
    }
    double fcn_default(const double &phit){
        return 3.2+phit;
    }
    class Object{
        public:
            double (*fcn_ptr)(const double &) = NULL;
            Object() {
                fcn_ptr = &fcn_default;
            }
    };

    int main(){
        Object test1,test2;
        cout << (test1.*fcn_ptr)(2) << endl; // can not compile here
        test2.fcn_ptr = &fcn_mod;
        //cout << (test2.*fcn_ptr)(2) << endl; // and here
        cout << "test" << endl;
    }

这也是一个更好的方法:

    #include <iostream>
    using namespace std;
    double fcn_mod(const double &phit){
        return 1.2+phit;
    }
    class Object{
        public:
            Object() {
                fcn_ptr = &fcn_default;
            }
            double (*fcn_ptr)(const double &) = NULL;
        private :
            static double fcn_default(const double &phit){
                return 3.2+phit;
            }
    };
    int main(){
        Object test1,test2;
        cout << (test1.*fcn_ptr)(2) << endl; // can not compile here
        test2.fcn_ptr = &fcn_mod;
        cout << (test2.*fcn_ptr)(2) << endl; // and here
        cout << "test" << endl;
    }

+++++ UPDATE 2 +++++

如果我想通过这个函数访问类的成员该怎么办?

最简单的解决方案是不能从fcn_mod中访问类成员(aa)。

#include <iostream>
using namespace std;
double fcn_mod(const double &phit){
    return 1.2 + phit + aa*0.001; // can not compile here
}
class Object{
    public:
        Object() {
            fcn_ptr = &Object::fcn_default;
            aa = 4;
        }
        double (*fcn_ptr)(const double &) = NULL;
        double aa;
    private:
        static double fcn_default(const double &phit){
            return 3.2 + phit + aa*0.001; // and here
        }
};
int main(){
    Object test1,test2;
    cout << (test1.fcn_ptr)(2) << endl;
    test2.fcn_ptr = &fcn_mod;
    cout << (test2.fcn_ptr)(2) << endl;
    cout << "test" << endl;
}

但是使用std::bind和std::function的解决方案也不需要。我可以传递一种"静态"参数的函数指针?

我添加了一个网关功能。

#include <iostream>
using namespace std;
double fcn_mod(const double &phit){
    return 1.2 + phit;
}
class Object{
    public:
        Object() {
            fcn_ptr = &Object::fcn_default;
            aa = 4;
        }
        double do_something(const double &phit){
            return this->fcn_ptr(phit+aa*0.001);
        }
        double (*fcn_ptr)(const double &);
        double aa;
    private:
        static double fcn_default(const double &phit){
            return 3.2 + phit;
        }
};
int main(){
    Object test1,test2;
    cout << test1.do_something(2) << endl; // can not compile here
    test2.fcn_ptr = &fcn_mod;
    cout << test2.do_something(2) << endl; // and here
    cout << "test" << endl;
}