Question

我有一个通用的数学方法，它在一组函数下运行（有很多变量和状态，所以它不能是静态的）。我在父类中实现了方法，我想在每个子类中声明一组不同的函数我试着做这样的事情：

class A {
public:
    typedef int (A::*func)();
    func * fs;
    void f() { /*call functions from this->fs*/ }
};

class B : public A {
public:
    int smth;

    B(int smth) {
         this->smth = smth; //user-provided variables

        //there may be a lot of functions with same interface
        this->fs = new func[1];
        fs[0] = &B::f;
    }

    int f() {
        return smth + 1;
    }
};

失败并出现此错误：错误C2440：'='：无法从'int（__thiscall B :: *）（void）'转换为'A :: func'

或者“IntelliSense：指向绑定函数的指针只能用于调用函数”，如果我尝试使用＆amp; this-＆gt; f;

Answer 1

奇怪的重复模板模式会有所帮助。

template<typename Derived>
class A {
public:
    typedef int (Derived::*func)();
    func * fs;
    void f()
    {
        Derived* const This = static_cast<Derived*>(this);
        /* call functions like (This->*(fs[0]))() */
    }
};

class B : public A<B> {
public:
    int smth;

    B(int smth) {
         this->smth = smth; //user-provided variables

        //there may be a lot of functions with same interface
        this->fs = new func[1];
        fs[0] = &B::f;
    }

    int f() {
        return smth + 1;
    }
};

Answer 2

也许boost::function数组可行：

#include <boost/function.hpp>
#include <boost/lambda/bind.hpp>
#include <vector>

struct A
{
    virtual ~A(void) {}; // base classes should always have virtual destructors

    typedef std::vector<boost::function<int(void)> > function_array;
    function_array mFunctions;
};

struct B : A
{
    B(int pX) : mX(pX) // use initializer lists
    {
        mFunctions.push_back(boost::lambda::bind(&B::foo, this));
    }

    int foo(void)
    {
        return mX + 1;
    }

    int mX;
};

int main(void)
{
    B b(5);
    A& a(b);

    int x = a.mFunctions[0]();
    // x is 6
}

您的目标仍不明确。（在上面，A作为基类并没有意义。为什么没有像get_functions这样的函数只返回一个所有设置并准备使用的函数数组，例如？）

这里你的大局是什么？听起来你正在寻找虚拟功能：

struct A
{
    virtual ~A(void) {} // base classes should always have virtual destructors

    virtual int foo(void) const = 0;
};

struct B : A
{
    B(int pX) : mX(pX) {}

    int foo(void) const
    {
        return mX + 1;
    }

    int mX;
};

int main(void)
{
    B b(5);
    A* a = &b;

    int x = a->f(); // calls B::foo(), polymorphic behavior thanks to virtual
    // x is 6
}

C ++函数指针和继承

2 个答案: