C++ 快速绑定成员函数的方法答案

【问题标题】：C++ fast ways to bind member functionsC++ 快速绑定成员函数的方法
【发布时间】：2014-01-26 20:47:55
【问题描述】：

我有一个class transition，里面有一个成员函数rate。我正在寻求一种方法，该方法允许我将自定义设计的 rates 插入到 transition 的瞬间中，在这些瞬间被创建之后，并且在运行时会很快！

我想优化代码以提高速度。 rate 进行简单的计算，但被程序非常频繁且多次调用。所以我想我应该避免使用虚函数......问题：在 C++ 中实现这一目标的其他最佳方法是什么（模板、boost、......）？关于特定方法的速度的评论将不胜感激。谢谢！

class transition {
public: 
  transition() : vec() {}
  double rate(T_vec::iterator a) { return ...; }
private: 
  T_vec vec;
};

/* custom rate #1 */
double my_rate_1( T_vec::iterator) { 
  /* do something */ 
  return ans; 
}

/* custom rate #2 */
double my_rate_2( T_vec::iterator) { 
  /* do something */ 
  return ans; 
}

const int N=10;

int main (void) {

  vector<transition*> ts(N);
  for(int i=0;i!=N;++i) ts[i] = new transition;

  /* How to efficiently implement the pseudo code that follows? */  

  ts[0]->rate = my_rate_1;
  ts[1]->rate = my_rate_2;

  /* ... */     

}

【问题讨论】：

“名称查找”是什么意思？这是在编译时完成的。
您需要静态（编译时）解决方案（例如：模板）还是像策略模式这样的动态（运行时可配置）解决方案？
@piotruś - 这是伪代码，因为我不知道如何以速度为目标首先做到这一点（在编译时插入自定义函数）
@KarolyHorvath static（编译时间，模板）就可以了！
如果您需要运行时多态性，对 std::function 与裸函数指针进行基准测试，它们应该具有可比性，但 std::function 更灵活且 C++ 风格。

标签： c++ boost stl

【解决方案1】：

至少有三种方法可以实现这一点。

选项 1 是虚拟方法。创建实例后无法绑定方法，但创建后可以将所有派生类视为transition。

class transition {
    ...
    virtual double rate(T_vec::iterator a) = 0;
};

class my_transition_1 : public transition {
    ...
    double rate(T_vec::iterator a) { ... }
};
class my_transition_2 : public transition {
    ...
    double rate(T_vec::iterator a) { ... }
};

选项 2 是回调。创建对象后，您可以在运行时更改方法。这是最有活力的。在这种情况下，它的开销略高，因为迭代器有一个额外的副本构造，编译器更难优化掉间接调用。

class transition {
public:
    ....
    typedef double (*RateFunction)(T_vec::iterator a);
    void set_rate(RateFunction r) { _fun = r; }
    double rate(T_vec::iterator a) { return (*_fun)(a); }
private:
    RateFunction _fun;
};
double my_rate_1(T_vec::iterator a) {
    ...
}
...
transition t;
t.set_rate(my_rate_1);

选项 3 是函子模板。您必须在构建时指定所有内容，但这避免了间接调用并具有最佳性能。

template <typename Rate>
class transition {
    double rate(T_vec::iterator a) {
        return Rate()(a);
    }
};
class my_rate_1 {
    double operator()(T_vec::iterator a) {
        ....
    }
};
class my_rate_2 {
    double operator()(T_vec::iterator a) {
        ....
    }
};

transition<my_rate_1> t1;
transition<my_rate_2> t2;

选项 4 不可扩展，但您避免了间接函数调用，并有机会在创建对象后设置速率。

class transition {
public:
    enum RateCode {
        RATE_1,
        RATE_2,
        ...
    }
    double rate(T_vec::iterator i) {
        switch (_rate_code) {
        case RATE_1: {
            ...
            return result;
            }
        case RATE_2: {
            ...
            return result;
            }
        default:
            assert(false);
        }
    }
    void setRate(RateCode r) { _rate_code = r; }
private:
    RateCode _rate_code;
}

【讨论】：

鉴于每种设计模式都是可接受的，您如何按速度对这三个选项进行排名？如果rate 只包含几个算术运算，比如return vec[0]*par + vec[1]*vec[2];，那么可以预期最慢和最快的运算之间的性能差异是多少？谢谢你的好答案，顺便说一句！
选项 3 不错，但我看不出如何先创建对象/引用向量，然后再插入费率。
速度为：回调
我添加了第四个选项，它比 virtuals 更快，允许您将对象插入容器中，但不可扩展。

【解决方案2】：

如果您想绑定到任意函数，请查看FastDelegate 文章。还有一个代表想法的article of a more portable implementation。

如果您可以安排您的代码，以便在编译时知道特定实例，那么这将更快，假设编译器可以很好地完成它的工作。它更快的原因是真正的委托意味着对函数指针的调用，这打破了当今 CPU 中的推测执行和流水线。

您可能还想阅读 C++11。在 C++11 中，lambda 函数（可以传递的内联编写函数）是一个重要的扩展，我希望编译器努力优化它们。

【讨论】：