需要处理 C++ 类成员的静态函数

Question

我必须在两个软件之间架起某种桥梁，但我遇到了一个我不知道如何处理的问题。希望有人会提出有趣且（最好）可行的建议。

这是背景：我有一个 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()”）。

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

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

编辑：好的，这是我必须做的简化示例，希望它是清晰和正确的：

// 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();

}

Answer 1

按照初始问题下方 spencercw 的建议，我尝试了“您设置为指向 this 的静态成员变量”解决方案（在软件套件的上下文中，全局变量会很棘手且很危险）。

实际上我发现代码中已经实现了类似的东西（我没有写）：

static void*          currentObject;

所以我只是用它，因为

((MyClass*)currentObject)->SomeComputation();

确实有效，谢谢！！！

Answer 2

您可以将 result = SomeComputation(); 从静态函数中移出，并在调用静态函数之前将其放入 BigFunction。

Answer 3

指向非静态成员函数的指针有点难以处理。最简单的解决方法是向函数添加一个不透明的指针参数，然后您可以将其转换为指向“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()可以通过不透明的指针访问私有的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;
}

如果你真的不能改变函数原型，你可以使用一个全局指针，但是如果你的类实例不止一个，这会带来各种各样的问题。这通常是不好的做法。

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;
}

Answer 4

不可重入和非线程安全的方式是使用全局变量传递“this”地址。