C 快速绑定成员功能的方法

C++ fast ways to bind member functions

本文关键字：功能 方法 成员 绑定      更新时间：2023-10-16

我有一个 class transition，内部，成员函数 rate。我要求一种方法，可以使我可以在创建这些瞬间之后将自定义设计的rate S插入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;
  /* ... */     
}

至少有三种方法可以实现此目标。

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

如果要绑定到任意功能，请检查FastDelegate文章。还有一篇关于代表想法更便携的实现的文章。

如果您可以安排代码，以便在编译时已知特定实例，则假设编译器的工作效果很好，这将更快。之所以更快的原因是真正的代表意味着呼叫函数指针，这打破了当今CPU中的投机执行和管道。

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

相关文章：