库代码：
class Resource
{
public:
typedef void (*func_sig)(int, char, double, void*);
//Registration
registerCallback(void* app_obj, func_sig func)
{
_app_obj = app_obj;
_func = func;
}
//Calling when the time comes
void call_app_code()
{
_func(231,'a',432.4234,app_obj);
}
//Other useful methods
private:
void* app_obj;
func_sig _func;
//Other members
};
应用程序代码：
class App
{
public:
void callme(int, char, double);
//other functions, members;
};
void callHelper(int i, char c, double d, void* app_obj)
{
static_cast<App*>(app_obj)->callme(i,c,d);
}
int main()
{
App a;
Resource r;
r.registercallback(&a, callHelper);
//Do something
}
以上是一个最小实现的回调机制。 它是更冗长，不支持绑定，占位符等，比如std ::功能。 如果我使用std::function或boost::function对于上述用例，是否会有任何性能缺点？ 这个回调将是在实时应用的非常非常关键路径。 我听说的boost ::函数使用虚函数来完成实际的调度。 那将是优化掉了，如果有不涉及绑定/占位符？
更新
对于那些有兴趣在最新的编译器检查组件： https://gcc.godbolt.org/z/-6mQvt
我不知道自己相当频繁了，所以我就开始写一些非常小的基准测试，试图模拟通过为每个函数指针回调版本环原子计数器的性能。
请记住，这些都是该做的只有一件事，原子的递增计数器功能裸电话;
通过检查生成的汇编输出可能会发现，即裸C-函数指针循环被编译成3组CPU的指令;
一个C ++ 11的std::function调用只是增加了2个CPU指令，因此5我们的榜样。 作为一个结论：这是绝对不会不管你使用的函数指针技术，什么样的方式，开销差异在任何情况下非常小。
（（然而混淆的是，所分配的lambda表达式似乎运行比其它快，甚至比C-之一。））
编译与例如： clang++ -o tests/perftest-fncb tests/perftest-fncb.cpp -std=c++11 -pthread -lpthread -lrt -O3 -march=native -mtune=native
#include <functional>
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
typedef unsigned long long counter_t;
struct Counter {
volatile counter_t bare;
volatile counter_t cxx;
volatile counter_t cxo1;
volatile counter_t virt;
volatile counter_t lambda;
Counter() : bare(0), cxx(0), cxo1(0), virt(0), lambda(0) {}
} counter;
void bare(Counter* counter) { __sync_fetch_and_add(&counter->bare, 1); }
void cxx(Counter* counter) { __sync_fetch_and_add(&counter->cxx, 1); }
struct CXO1 {
void cxo1(Counter* counter) { __sync_fetch_and_add(&counter->cxo1, 1); }
virtual void virt(Counter* counter) { __sync_fetch_and_add(&counter->virt, 1); }
} cxo1;
void (*bare_cb)(Counter*) = nullptr;
std::function<void(Counter*)> cxx_cb;
std::function<void(Counter*)> cxo1_cb;
std::function<void(Counter*)> virt_cb;
std::function<void(Counter*)> lambda_cb;
void* bare_main(void* p) { while (true) { bare_cb(&counter); } }
void* cxx_main(void* p) { while (true) { cxx_cb(&counter); } }
void* cxo1_main(void* p) { while (true) { cxo1_cb(&counter); } }
void* virt_main(void* p) { while (true) { virt_cb(&counter); } }
void* lambda_main(void* p) { while (true) { lambda_cb(&counter); } }
int main()
{
pthread_t bare_thread;
pthread_t cxx_thread;
pthread_t cxo1_thread;
pthread_t virt_thread;
pthread_t lambda_thread;
bare_cb = &bare;
cxx_cb = std::bind(&cxx, std::placeholders::_1);
cxo1_cb = std::bind(&CXO1::cxo1, &cxo1, std::placeholders::_1);
virt_cb = std::bind(&CXO1::virt, &cxo1, std::placeholders::_1);
lambda_cb = [](Counter* counter) { __sync_fetch_and_add(&counter->lambda, 1); };
pthread_create(&bare_thread, nullptr, &bare_main, nullptr);
pthread_create(&cxx_thread, nullptr, &cxx_main, nullptr);
pthread_create(&cxo1_thread, nullptr, &cxo1_main, nullptr);
pthread_create(&virt_thread, nullptr, &virt_main, nullptr);
pthread_create(&lambda_thread, nullptr, &lambda_main, nullptr);
for (unsigned long long n = 1; true; ++n) {
sleep(1);
Counter c = counter;
printf(
"%15llu bare function pointer\n"
"%15llu C++11 function object to bare function\n"
"%15llu C++11 function object to object method\n"
"%15llu C++11 function object to object method (virtual)\n"
"%15llu C++11 function object to lambda expression %30llu-th second.\n\n",
c.bare, c.cxx, c.cxo1, c.virt, c.lambda, n
);
}
}
std::function执行功能类型类型擦除并没有实现它的方法不止一种，所以你也许应该添加您使用的是得到一个确切的答案，编译器的版本。
boost::function在很大程度上等同于std::function ，并配备了一个FAQ上调用的开销项，一些业绩普通区间 。 那些给一个函数对象如何执行一些提示。 如果这适用于你的情况，取决于具体的实现，但数量不宜显著不同。
我运行使用快速基准谷歌基准这些结果如下：
Run on (4 X 2712 MHz CPU s)
----------------------------------------------------------
Benchmark Time CPU Iterations
----------------------------------------------------------
RawFunctionPointer 11 ns 11 ns 56000000
StdBind 12 ns 12 ns 64000000
StdFunction 11 ns 11 ns 56000000
Lambda 9 ns 9 ns 64000000
看来，最优化的解决方案是使用lambda表达式（就像在这个线程中提到用户christianparpart）。 我用基准的代码可以在下面找到。
#include <benchmark/benchmark.h>
#include <cstdlib>
#include <cstdio>
#include <functional>
static volatile int global_var = 0;
void my_int_func(int x)
{
global_var = x + x + 3;
benchmark::DoNotOptimize(global_var);
benchmark::DoNotOptimize(x);
}
static void RawFunctionPointer(benchmark::State &state)
{
void (*bar)(int) = &my_int_func;
srand (time(nullptr));
for (auto _ : state)
{
bar(rand());
benchmark::DoNotOptimize(my_int_func);
benchmark::DoNotOptimize(bar);
}
}
static void StdFunction(benchmark::State &state)
{
std::function<void(int)> bar = my_int_func;
srand (time(nullptr));
for (auto _ : state)
{
bar(rand());
benchmark::DoNotOptimize(my_int_func);
benchmark::DoNotOptimize(bar);
}
}
static void StdBind(benchmark::State &state)
{
auto bar = std::bind(my_int_func, std::placeholders::_1);
srand (time(nullptr));
for (auto _ : state)
{
bar(rand());
benchmark::DoNotOptimize(my_int_func);
benchmark::DoNotOptimize(bar);
}
}
static void Lambda(benchmark::State &state)
{
auto bar = [](int x) {
global_var = x + x + 3;
benchmark::DoNotOptimize(global_var);
benchmark::DoNotOptimize(x);
};
srand (time(nullptr));
for (auto _ : state)
{
bar(rand());
benchmark::DoNotOptimize(my_int_func);
benchmark::DoNotOptimize(bar);
}
}
BENCHMARK(RawFunctionPointer);
BENCHMARK(StdBind);
BENCHMARK(StdFunction);
BENCHMARK(Lambda);
BENCHMARK_MAIN();
文章来源: Performance of std::function compared to raw function pointer and void* this?
