如何将类成员函数作为回调传递？

StackOverflow https://stackoverflow.com/questions/400257

题

我正在使用一个API，要求我将函数指针作为回调传递。我正在尝试从我的类中使用此API，但是我遇到了编译错误。

以下是我在构造函数中所做的事情：

m_cRedundencyManager->Init(this->RedundencyManagerCallBack);

这不能编译 - 我收到以下错误：

  

错误8错误C3867：'CLoggersInfra :: RedundencyManagerCallBack'：函数调用缺少参数列表;使用'<！> amp; CLoggersInfra :: RedundencyManagerCallBack'创建指向成员的指针

我尝试了使用&CLoggersInfra::RedundencyManagerCallBack的建议 - 对我不起作用。

对此有何建议/解释？

我正在使用VS2008。

谢谢！

有帮助吗？

解决方案

这不起作用，因为成员函数指针不能像普通函数指针一样处理，因为它需要一个<！> quot; this <！> quot;对象参数。

相反，您可以按如下方式传递静态成员函数，就像这方面的普通非成员函数一样：

m_cRedundencyManager->Init(&CLoggersInfra::Callback, this);

该功能可以定义如下

static void Callback(int other_arg, void * this_pointer) {
    CLoggersInfra * self = static_cast<CLoggersInfra*>(this_pointer);
    self->RedundencyManagerCallBack(other_arg);
}

其他提示

这是一个简单的问题，但答案非常复杂。简短的回答是你可以做你正在尝试用std :: bind1st或boost :: bind做的事情。答案越长越好。

建议使用<！> amp; CLoggersInfra :: RedundencyManagerCallBack编译器是正确的。首先，如果RedundencyManagerCallBack是一个成员函数，则该函数本身不属于CLoggersInfra类的任何特定实例。它属于类本身。如果您之前曾调用过静态类函数，您可能已经注意到使用了相同的SomeClass :: SomeMemberFunction语法。由于函数本身是“静态的”，因为它属于类而不是特定的实例，因此使用相同的语法。 '<！>放大器''是必要的，因为从技术上讲你不直接传递函数 - 函数不是C ++中的真实对象。相反，你在技术上传递函数的内存地址，即指向函数指令在内存中开始的指针。结果是相同的，你有效地'传递函数'作为参数。

但在这种情况下，这只是问题的一半。正如我所说，RedundencyManagerCallBack该函数不属于任何特定实例。但听起来你想把它作为一个特定实例的回调传递给它。要了解如何执行此操作，您需要了解成员函数的真正含义：常规未定义的任何类函数以及额外的隐藏参数。

例如：

class A {
public:
    A() : data(0) {}
    void foo(int addToData) { this->data += addToData; }

    int data;
};

...

A an_a_object;
an_a_object.foo(5);
A::foo(&an_a_object, 5); // This is the same as the line above!
std::cout << an_a_object.data; // Prints 10!

A :: foo需要多少个参数？通常我们会说1.但是在幕后，foo真的需要2.看看A :: foo的定义，它需要一个特定的A实例，以便'this'指针有意义（编译器需要知道什么'这是）。通常通过语法MyObject.MyMemberFunction（）指定您想要的“this”的方式。但这只是将MyObject的地址作为第一个参数传递给MyMemberFunction的语法糖。类似地，当我们在类定义中声明成员函数时，我们不会在参数列表中放入“this”，但这只是语言设计者提供的一种保存输入的礼物。相反，你必须指定一个成员函数是静态的，以选择退出它自动获得额外的'this'参数。如果C ++编译器将上面的例子转换为C代码（原始的C ++编译器实际上就是这样工作的话），它可能会写成这样的东西：

struct A {
    int data;
};

void a_init(A* to_init)
{
    to_init->data = 0;
}

void a_foo(A* this, int addToData)
{ 
    this->data += addToData;
}

...

A an_a_object;
a_init(0); // Before constructor call was implicit
a_foo(&an_a_object, 5); // Used to be an_a_object.foo(5);

回到你的例子，现在有一个明显的问题。 'Init'想要一个指向一个带一个参数的函数的指针。但是<！> amp; CLoggersInfra :: RedundencyManagerCallBack是一个指向函数的指针，它接受两个参数，它是普通参数和秘密'this'参数。这就是为什么你仍然会遇到编译器错误（作为旁注：如果你曾经使用过Python，那么这种混淆就是为什么所有成员函数都需要'self'参数）。

处理此问题的详细方法是创建一个特殊对象，该对象包含指向所需实例的指针，并且具有名为“run”或“execute”（或重载“（）”运算符）的成员函数，获取成员函数的参数，并简单地在存储的实例上使用这些参数调用成员函数。但这需要你改变'Init'来取你的特殊对象而不是原始的函数指针，听起来像Init是别人的代码。每次出现这个问题时都会制作一个特殊的类会导致代码膨胀。

现在，最后，好的解决方案，boost :: bind和boost :: function，你可以在这里找到每个文档：

boost :: bind docs ， boost :: function docs

boost :: bind将让你获取一个函数，并为该函数提供一个参数，并在该参数被“锁定”的位置创建一个新函数。所以，如果我有一个添加两个整数的函数，我可以使用boost :: bind来创建一个新函数，其中一个参数被锁定为5。这个新函数只接受一个整数参数，并且总是会添加5个它。使用这种技术，您可以将隐藏的'this'参数“锁定”为特定的类实例，并生成一个只接受一个参数的新函数，就像您想要的那样（注意隐藏参数始终是第一个参数，正常参数在它之后按顺序排列）。查看boost :: bind文档中的示例，他们甚至专门讨论将其用于成员函数。从技术上讲，你可以使用一个名为std :: bind1st的标准函数，但boost :: bind更通用。

当然，还有一个问题。 boost :: bind会为你做一个很好的boost :: function，但这在技术上仍然不像Init可能想要的原始函数指针。值得庆幸的是，boost提供了一种将boost :: function转换为原始指针的方法，如StackOverflow中所述此处。它如何实现这一点超出了这个答案的范围，尽管它也很有趣。

如果这看起来很荒谬，请不要担心 - 你的问题与C ++的几个黑暗角落相交，而且一旦你学会了，boost :: bind就非常有用了。

C ++ 11更新：您现在可以使用捕获'this'的lambda函数代替boost :: bind。这基本上让编译器为你生成相同的东西。

此答案是对上述评论的回复，不适用于VisualStudio 2008，但应该首选更新的编译器。

同时你不必再使用void指针了，因为 std::bind 和 std::function 可用。 一个优势（与void指针相比）是类型安全性，因为返回类型和参数是使用std::placeholders显式声明的：

// std::function<return_type(list of argument_type(s))>
void Init(std::function<void(void)> f);

然后，您可以使用return f("MyString");创建函数指针并将其传递给Init：

auto cLoggersInfraInstance = CLoggersInfra();
auto callback = std::bind(&CLoggersInfra::RedundencyManagerCallBack, cLoggersInfraInstance);
Init(callback);

完整示例，将Init用于成员，静态成员和非成员函数：

#include <functional>
#include <iostream>
#include <string>

class RedundencyManager // incl. Typo ;-)
{
public:
    // std::function<return_type(list of argument_type(s))>
    std::string Init(std::function<std::string(void)> f) 
    {
        return f();
    }
};

class CLoggersInfra
{
private:
    std::string member = "Hello from non static member callback!";

public:
    static std::string RedundencyManagerCallBack()
    {
        return "Hello from static member callback!";
    }

    std::string NonStaticRedundencyManagerCallBack()
    {
        return member;
    }
};

std::string NonMemberCallBack()
{
    return "Hello from non member function!";
}

int main()
{
    auto instance = RedundencyManager();

    auto callback1 = std::bind(&NonMemberCallBack);
    std::cout << instance.Init(callback1) << "\n";

    // Similar to non member function.
    auto callback2 = std::bind(&CLoggersInfra::RedundencyManagerCallBack);
    std::cout << instance.Init(callback2) << "\n";

    // Class instance is passed to std::bind as second argument.
    // (heed that I call the constructor of CLoggersInfra)
    auto callback3 = std::bind(&CLoggersInfra::NonStaticRedundencyManagerCallBack,
                               CLoggersInfra()); 
    std::cout << instance.Init(callback3) << "\n";
}

可能的输出：

Hello from non member function!
Hello from static member callback!
Hello from non static member callback!

此外，使用 <=> ，您可以动态地将参数传递给回调（例如，如果f具有字符串参数，则可以在<=>中使用<=>。）

Init采取什么样的论据？什么是新的错误消息？

C ++中的方法指针有点难以使用。除了方法指针本身，您还需要提供一个实例指针（在您的情况下为this）。也许<=>期望它作为一个单独的论点？

指向类成员函数的指针与指向函数的指针不同。类成员采用隐式额外参数（ this 指针），并使用不同的调用约定。

如果您的API需要非成员回调函数，那么您需要传递给它。

是否m_cRedundencyManager能够使用会员功能？大多数回调都设置为使用常规函数或静态成员函数。在C ++ FAQ Lite上查看此页面了解更多信息。

更新：您提供的函数声明显示void yourCallbackFunction(int, void *)期望表单的函数：void *。因此，在这种情况下，成员函数作为回调是不可接受的。静态成员函数可以工作，但如果在您的情况下这是不可接受的，则以下代码也可以使用。请注意，它使用来自<=>的邪恶演员。


// in your CLoggersInfra constructor:
m_cRedundencyManager->Init(myRedundencyManagerCallBackHandler, this);


// in your CLoggersInfra header:
void myRedundencyManagerCallBackHandler(int i, void * CLoggersInfraPtr);


// in your CLoggersInfra source file:
void myRedundencyManagerCallBackHandler(int i, void * CLoggersInfraPtr)
{
    ((CLoggersInfra *)CLoggersInfraPtr)->RedundencyManagerCallBack(i);
}

我可以看到init具有以下覆盖：

Init(CALLBACK_FUNC_EX callback_func, void * callback_parm)

其中CALLBACK_FUNC_EX是

typedef void (*CALLBACK_FUNC_EX)(int, void *);

<问答来自< a href =“https://isocpp.org/wiki/faq”rel =“nofollow noreferrer”> C ++ FAQ Lite 我认为很好地涵盖了你的问题以及答案所涉及的考虑因素。我链接的网页的简短片段：

  

别＃8217 <！>;吨

     

因为没有要调用的对象，成员函数就没有意义   它可以<！>＃8217;直接这样做（如果X Window系统是   用C ++重写，它可能会传递对周围对象的引用，   不只是指向功能;这些物体自然会体现出来   所需的功能，可能还有很多）。

Necromancing。点击 我认为迄今为止的答案有点不清楚。

我们举个例子：

假设您有一个像素数组（ARGB int8_t值数组）

// A RGB image
int8_t* pixels = new int8_t[1024*768*4];

现在您要生成PNG。 为此，您可以调用函数toJpeg 

bool ok = toJpeg(writeByte, pixels, width, height);

其中writeByte是回调函数

void writeByte(unsigned char oneByte)
{
    fputc(oneByte, output);
}

问题在于：FILE *输出必须是全局变量。点击 如果您处于多线程环境（例如，http服务器），则非常糟糕。

因此，您需要某种方法使输出成为非全局变量，同时保留回调签名。

我想到的最直接的解决方案是一个闭包，我们可以使用带有成员函数的类来模拟它。 

class BadIdea {
private:
    FILE* m_stream;
public:
    BadIdea(FILE* stream)  {
        this->m_stream = stream;
    }

    void writeByte(unsigned char oneByte){
            fputc(oneByte, this->m_stream);
    }

};

然后再做

FILE *fp = fopen(filename, "wb");
BadIdea* foobar = new BadIdea(fp);

bool ok = TooJpeg::writeJpeg(foobar->writeByte, image, width, height);
delete foobar;
fflush(fp);
fclose(fp);

然而，与预期相反，这不起作用。

原因是，C ++成员函数有点像C＃扩展函数一样实现。

所以你有

class/struct BadIdea
{
    FILE* m_stream;
}

和

static class BadIdeaExtensions
{
    public static writeByte(this BadIdea instance, unsigned char oneByte)
    {
         fputc(oneByte, instance->m_stream);
    }

}

因此，当您想要调用writeByte时，您不仅需要传递writeByte的地址，还需要传递BadIdea实例的地址。

所以当你有一个writeByte程序的typedef时，它看起来像这个

typedef void (*WRITE_ONE_BYTE)(unsigned char);

你有一个看起来像这样的writeJpeg签名

bool writeJpeg(WRITE_ONE_BYTE output, uint8_t* pixels, uint32_t 
 width, uint32_t height))
    { ... }

从根本上不可能将双地址成员函数传递给单地址函数指针（不修改writeJpeg），并且没有办法绕过它。

你可以在C ++中做的第二件事是使用lambda函数：

FILE *fp = fopen(filename, "wb");
auto lambda = [fp](unsigned char oneByte) { fputc(oneByte, fp);  };
bool ok = TooJpeg::writeJpeg(lambda, image, width, height);

但是，因为lambda没有什么不同，只是将实例传递给隐藏类（例如<！>“BadIdea <！>”; -class），您需要修改writeJpeg的签名。

lambda优于手动类的优点是你只需要更改一个typedef 

using WRITE_ONE_BYTE = std::function<void(unsigned char)>;

到

auto f = std::bind(&BadIdea::writeByte, &foobar);

然后你可以保持其他一切都不受影响。

您也可以使用std :: bind 

./configure
make
make install

gcc main.c -l:libffcall.a -o ma

但是，在幕后，只需创建一个lambda函数，然后还需要更改typedef。

所以不，没有办法将成员函数传递给需要静态函数指针的方法。

但是只要你控制了源码，lambda就是最简单的方法。点击 否则，你运气不好。点击 你无法用C ++做任何事情。

注意：
std :: function需要#include <functional>

但是，由于C ++允许你也使用C，你可以使用 libffcall 在普通C中，如果你不介意链接一个依赖。

从GNU下载libffcall（至少在ubuntu上，不要使用发行版提供的软件包 - 它已损坏），解压缩。 

#include <callback.h>

// this is the closure function to be allocated 
void function (void* data, va_alist alist)
{
     int abc = va_arg_int(alist);

     printf("data: %08p\n", data); // hex 0x14 = 20
     printf("abc: %d\n", abc);

     // va_start_type(alist[, return_type]);
     // arg = va_arg_type(alist[, arg_type]);
     // va_return_type(alist[[, return_type], return_value]);

    // va_start_int(alist);
    // int r = 666;
    // va_return_int(alist, r);
}



int main(int argc, char* argv[])
{
    int in1 = 10;

    void * data = (void*) 20;
    void(*incrementer1)(int abc) = (void(*)()) alloc_callback(&function, data);
    // void(*incrementer1)() can have unlimited arguments, e.g. incrementer1(123,456);
    // void(*incrementer1)(int abc) starts to throw errors...
    incrementer1(123);
    // free_callback(callback);
    return EXIT_SUCCESS;
}

main.c中：

add_library(libffcall STATIC IMPORTED)
set_target_properties(libffcall PROPERTIES
        IMPORTED_LOCATION /usr/local/lib/libffcall.a)
target_link_libraries(BitmapLion libffcall)

如果使用CMake，请在add_executable

之后添加链接库 
target_link_libraries(BitmapLion ffcall)

或者你可以动态链接libffcall

<*>

注意：
您可能希望包含libffcall头文件和库，或者创建一个包含libffcall内容的cmake项目。

许可以下： CC-BY-SA 和 归因
不隶属于 StackOverflow
scroll top