Question

假设我有一个具有大约四个布尔标志的通用函数：

int do_something(int arg, bool flag1, bool flag2, bool flag3, bool flag4) {
  for(int i = 0; i < 1000000; i++) {
    if(flag1)
      // Do something 1
    if(flag2)
      // Do something 2
    if(flag3)
      // Do something 3
    if(flag4)
      // Do something 4
    //Do something else 5
  }
}

但是我不想在内部循环中为这些标志分支产生任何费用，所以我将它们更改为模板（允许编译器优化条件）：

template<bool flag1, bool flag2, bool flag3, bool flag4>
int do_something_helper(int arg) {
  for(int i = 0; i < 1000000; i++) {
    if(flag1)
      // Do something 1
    if(flag2)
      // Do something 2
    if(flag3)
      // Do something 3
    if(flag4)
      // Do something 4
    //Do something else 5
  }
}

如何立即编写do_something方法？我知道的唯一方法如下：

int do_something(int arg, bool flag1, bool flag2, bool flag3, bool flag4) {
    if(flag1) {
      if(flag2) {
        if(flag3) {
          if(flag4) {
            return do_something_helper<true,true,true,true>(arg);
          }else{
            return do_something_helper<true,true,true,false>(arg);
          }
        }else{
          if(flag4) {
            return do_something_helper<true,true,false,true>(arg);
          }else{
            return do_something_helper<true,true,false,false>(arg);
          }
        }
      //... You get the picture
}

有没有办法让编译器自动编写上面的代码，所以我不必在我漂亮的代码库中包含这个丑陋的怪物？

Answer 1

我要做的是采用仿函数和一组参数以及参数索引和范围。然后我将用std::integral_constant<type, value>替换索引参数并调用仿函数。 bool的情况最简单，因为范围很明显，所以我先写一下。

然后，您可以链接此类替换和仿函数，以使用编译时类型替换每个bool。我将使用相同的仿函数，使用N次重载，esch将bool替换为std::integral_constant<bool, X>，其中X是template参数。

最后一个方法会使用integral_constant而不是bool来调用最终方法。

请注意，这会扩展为指数级的实例化，因此请小心。

参数操作代码写起来会很有趣。

这是live example。

有趣的是，执行上述操作的样板可能仍然比较庞大，但希望减少拼写错误并且更容易测试。

#include <iostream>
#include <tuple>

template<unsigned...Is> struct indexes {typedef indexes<Is...> type;};
template<unsigned min, unsigned max, unsigned...Is> struct make_indexes: make_indexes<min, max-1, max-1, Is...> {};
template<unsigned min, unsigned...Is> struct make_indexes<min, min, Is...>: indexes<Is...> {};

template<unsigned max, unsigned min=0>
using Indexes = typename make_indexes<min, max>::type;

template<unsigned index, typename Functor, typename... Args, unsigned... Before, unsigned... After>
void map_bool_to_compile_time_helper( indexes<Before...>, indexes<After...>, Functor&& f, std::tuple<Args...> args )
{
  if (std::get<index>( args )) {
    std::forward<Functor>(f)( std::get<Before>(args)..., std::true_type(), std::get<After>(args)... );
  } else {
    std::forward<Functor>(f)( std::get<Before>(args)..., std::false_type(), std::get<After>(args)... );
  }
}

template<unsigned index, typename Functor, typename... Args>
void map_bool_to_compile_time( Functor&& f, Args&&... args )
{
  map_bool_to_compile_time_helper<index>( Indexes<index>(), Indexes<sizeof...(Args), index+1>(), std::forward<Functor>(f), std::make_tuple<Args&&...>(std::forward<Args>(args)...) );
}

template<typename Functor, unsigned... indexes>
struct map_bools_to_compile_time_helper;

template<typename Functor, unsigned index, unsigned... indexes>
struct map_bools_to_compile_time_helper<Functor, index, indexes...> {
  Functor&& f;
  map_bools_to_compile_time_helper(Functor&& in):f(std::forward<Functor>(in)) {}
  template< typename... Args>
  void operator()( Args&&... args) const {
    map_bool_to_compile_time<index>( map_bools_to_compile_time_helper<Functor, indexes...>{std::forward<Functor>(f)}, std::forward<Args>(args)... );
  }
};
template<typename Functor>
struct map_bools_to_compile_time_helper<Functor> {
  Functor&& f;
  map_bools_to_compile_time_helper(Functor&& in):f(std::forward<Functor>(in)) {}
  template<typename... Args>
  void operator()( Args&&... args) const {
    std::forward<Functor>(f)(std::forward<Args>(args)...);
  }
};

template<unsigned... Is, typename Functor, typename... Args>
void map_bools_to_compile_time( indexes<Is...>, Functor&& f, Args&&... args ) {
  map_bools_to_compile_time_helper<Functor, Is...>{ std::forward<Functor>(f) }( std::forward<Args>(args)... );
}


struct test {
  template<bool b>
  void operator()( int x, std::integral_constant< bool, b > )  { std::cout << x << ": " << b <<"!\n"; } 
};

struct test2 {
  template<bool b0, bool b1, bool b2>
  void operator()( int x, std::integral_constant< bool, b0 >, std::integral_constant< bool, b1 >, std::integral_constant< bool, b2 > )
  {
    std::cout << x << ": " << b0 << b1 << b2 << "\n";
  }
};
int main() {
  map_bools_to_compile_time( indexes<1>(), test(), 1, true );
  map_bool_to_compile_time<1>( test(), 2, false );
  map_bools_to_compile_time( indexes<1,2,3>(), test2(), 3, true, false, true );
}

更新了对任意数量索引的任意数量参数的支持。

Answer 2

您可以使用模板来组织静态调度 - 这将允许使用函数重载替换分支语句。这是一个相当简单的想法，这是一个小例子：

template <int Val>
struct Int2Type
{
   static const int val_= Val;
};
int do_something(int arg, Int2Type<1>)
{
   // do smth when flag == 1
}

int do_something(int arg, Int2Type<2>)
{
   // do smth when flag == 2
}

...应用相同的原则（通过调用所需的重载函数的值的值）

将布尔标志更改为模板参数

2 个答案: