我必须在两个软件之间建立某种桥梁，但我面临着一个我不知道如何处理的问题。希望有人会提出有趣且(最好)可行的建议。

这是背景:我有一个 C++ 软件套件。我必须用另一个函数替换给定类中的某些函数，这没关系。问题是新函数调用了另一个必须是静态的函数，但必须处理类的成员。这是让我发疯的第二个功能。

如果函数不是静态的，我会得到以下错误:

error: argument of type ‘void (MyClass::)(…)’ does not match ‘void (*)(…)’

如果我将其设置为静态，则会出现以下错误:

error: cannot call member function ‘void
MyClass::MyFunction(const double *)’ without object

或

error: ‘this’ is unavailable for static member functions

取决于我是否使用“this”关键字(“Function()”或“this->Function()”)。

最后，类对象需要一些我无法传递给静态函数的参数(我无法修改静态函数原型(prototype))，这阻止了我在静态函数本身内创建一个新实例。

您将如何以最少的重写处理这种情况？

编辑:好的，这是我必须做的事情的简化示例，希望它清楚且正确:

// This function is called by another class on an instance of MyClass
MyClass::BigFunction()
{

    …
// Call of a function from an external piece of code, 
// which prototype I cannot change
    XFunction(fcn, some more args);
    …

}


// This function has to be static and I cannot change its prototype,
// for it to be passed to XFunction.  XFunction makes iterations on it
// changing parameters (likelihood maximization) which do not appear 
// on this sample
void MyClass::fcn(some args, typeN& result) 
{

// doesn't work because fcn is static
    result = SomeComputation();

// doesn't work, for the same reason
    result = this->SomeComputation(); 

// doesn't work either, because MyClass has many parameters
// which have to be set
    MyClass *tmp = new MyClass();
    result = tmp->SomeComputation();

}

最佳答案

指向非静态成员函数的指针处理起来有点棘手。最简单的解决方法就是向您的函数添加一个不透明的指针参数，然后您可以将其转换为指向“this”的指针，然后使用它执行您需要的操作。

这是一个非常简单的例子:

void doSomething(int (*callback)(void *usrPtr), void *usrPtr)
{
    // Do stuff...
    int value = callback(usrPtr);
    cout << value << "\n";
}

class MyClass
{
public:
    void things()
    {
        value_ = 42;
        doSomething(myCallback, this);
    }

private:
    int value_;

    static int myCallback(void *usrPtr)
    {
        MyClass *parent = static_cast<MyClass *>(usrPtr);
        return parent->value_;
    }
};

int main()
{
    MyClass object;
    object.things();
    return 0;
}

在此示例中，myCallback() 可以通过不透明指针访问私有(private)value_。

如果您想要更像 C++ 的方法，您可以考虑使用 Boost.Function 和 Boost.Bind，它们允许您将非静态成员函数作为回调传递:

void doSomething(boost::function<int ()> callback)
{
    // Do stuff...
    int value = callback();
    cout << value << "\n";
}

class MyClass
{
public:
    void things()
    {
        value_ = 42;
        doSomething(boost::bind(&MyClass::myCallback, this));
    }

private:
    int value_;

    int myCallback()
    {
        return value_;
    }
};

int main()
{
    MyClass object;
    object.things();
    return 0;
}

如果您确实无法更改函数原型(prototype)，则可以使用全局指针，但如果您的类实例不止一个，那么这会引发各种问题。这通常是不好的做法。

class MyClass;
static MyClass *myClass;

void doSomething(int (*callback)())
{
    // Do stuff...
    int value = callback();
    cout << value << "\n";
}

class MyClass
{
public:
    void things()
    {
        value_ = 42;
        myClass = this;
        doSomething(myCallback);
    }

private:
    int value_;

    static int myCallback()
    {
        return myClass->value_;
    }
};

int main()
{
    MyClass object;
    object.things();
    return 0;
}

关于c++ - 需要处理 C++ 类成员的静态函数，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/9429812/