有时，通过使用不变量的模板化内部实现，编译器可以更好地优化一段代码。例如，如果您在图像中有已知数量的 channel ，而不是像这样做:

Image::doOperation() {
    for (unsigned int i = 0; i < numPixels; i++) {
        for (unsigned int j = 0; i j mChannels; j++) {
            // ...
        }
    }
}

你可以这样做:

template<unsigned int c> Image::doOperationInternal() {
    for (unsigned int i = 0; i < numPixels; i++) {
        for (unsigned int j = 0; j < c; j++) {
            // ...
        }
    }
}

Image::doOperation() {
    switch (mChannels) {
        case 1: doOperation<1>(); break;
        case 2: doOperation<2>(); break;
        case 3: doOperation<3>(); break;
        case 4: doOperation<4>(); break;
    }
}

这允许编译器为不同的 channel 数生成不同的展开循环(这反过来可以极大地提高运行时效率，并且还可以进行不同的优化，例如 SIMD 指令等)。

然而，这通常会扩展为一些相当大的 case 语句，并且任何以这种方式优化的方法都必须具有展开的 case 语句。因此，假设我们有一个用于已知图像格式的 enum Format(其中枚举的值恰好映射到 channel 数)。由于枚举只有一定范围内的已知值，因此很想试试这个:

template<Image::Format f> Image::doOperationInternal() {
    for (unsigned int i = 0; i < numPixels; i++) {
        for (unsigned int j = 0; j < static_cast<unsigned int>(f); j++) {
            // ...
        }
    }
}

Image::doOperation() {
    const Format f = mFormat;
    doOperationInternal<f>();
}

然而，在这种情况下，编译器(理所当然地)提示 f 不是一个常量表达式，即使它只有一个有限的范围，理论上编译器可以生成 switch 逻辑来覆盖所有枚举值。

那么，我的问题是:是否有一种替代方法允许编译器生成不变值优化代码，而无需在每次函数调用时进行 switch-case 展开？

最佳答案

制作跳转表数组，然后调用。目标是创建各种函数的数组，然后进行数组查找并调用所需函数。

首先，我会做 C++11 的。 C++1y 包含自己的整数序列类型，并且易于编写 auto返回类型:C++11 将返回 void .

我们的仿函数类看起来像这样:

struct example_functor {
  template<unsigned N>
  static void action(double d) const {
    std::cout << N << ":" << d << "\n"; // or whatever, N is a compile time constant
  }
};

在 C++11 中，我们需要一些样板文件:

template<unsigned...> struct indexes {};
template<unsigned Max, unsigned... Is> struct make_indexes:make_indexes< Max-1, Max-1, Is... > {};
template<unsigned... Is> struct make_indexes<0, Is...>:indexes<Is...> {};

创建和模式匹配索引包。

界面如下所示:

template<typename Functor, unsigned Max, typename... Ts>
void invoke_jump( unsigned index, Ts&&... ts );

并且被称为:

invoke_jump<example_functor, 10>( 7, 3.14 );

我们首先创建一个助手:

template<typename Functor, unsigned... Is, typename... Ts>
void do_invoke_jump( unsigned index, indexes<Is...>, Ts&&... ts ) {
  static auto table[]={ &(Functor::template action<Is>)... };
  table[index]( std::forward<Ts>(ts)... )
}
template<typename Functor, unsigned Max, typename... Ts>
void invoke_jump( unsigned index, Ts&&... ts ) {
  do_invoke_jump( index, make_indexes<Max>(), std::forward<Ts>(ts)... );
}

创建一个 static Functor::action 的表格然后对它们进行查找并调用它。

在 C++03 中我们没有 ...语法，所以我们不得不手动做更多的事情，并且没有完美的转发。我要做的是创建一个 std::vector表格代替。

首先，一个运行 Functor.action<I>() 的可爱小程序对于我在 [开始，结束)中的顺序:

template<unsigned Begin, unsigned End, typename Functor>
struct ForEach:ForEach<Begin, End-1, Functor> {
  ForEach(Functor& functor):
    ForEach<Begin, End-1, Functor>(functor)
  {
    functor->template action<End-1>();
  }
};
template<unsigned Begin, typename Functor>
struct ForEach<Begin,Begin,Functor> {};

我承认这太可爱了(链是由构造函数依赖隐式创建的)。

然后我们用它来构建一个 vector上。

template<typename Signature, typename Functor>
struct PopulateVector {
  std::vector< Signature* >* target; // change the signature here to whatever you want
  PopulateVector(std::vector< Signature* >* t):target(t) {}
  template<unsigned I>
  void action() {
    target->push_back( &(Functor::template action<I>) );
  }
};

然后我们可以将两者联系起来:

template<typename Signature, typename Functor, unsigned Max>
std::vector< Signature* > make_table() {
  std::vector< Signature* > retval;
  retval.reserve(Max);
  PopulateVector<Signature, Functor> worker(&retval);
  ForEach<0, Max>( worker ); // runtime work basically done on this line
  return retval;
}

它将我们的跳转表构建为 std::vector .

然后我们可以很容易地调用跳转表的第I个元素。

struct example_functor {
  template<unsigned I>
  static void action() {
    std::cout << I << "\n";
  }
};
void test( unsigned i ) {
  static std::vector< void(*)() > table = make_table< void(), example_functor, 100 >();
  if (i < 100)
    table[i]();
}

当传递整数时 i打印它然后换行。

表中函数的签名可以是任何你想要的，所以你可以传入一个指向类型的指针并调用一个方法，用I作为编译时常量。 action方法必须是 static , 但它可以调用非 static基于其参数的方法。

C++03 的最大区别在于，您需要针对跳转表的不同签名使用不同的代码、大量机制(以及 std::vector 而不是静态数组)来构建跳转表。

在进行严肃的图像处理时，您会希望以这种方式生成扫描线函数，并且可能会在生成的扫描线函数的某处嵌入每像素操作。每条扫描线执行一次跳跃调度通常足够快，除非您的图像是 1 像素宽和 10 亿像素高。

以上代码的正确性还需要审核:它是在没有编译的情况下编写的。

关于c++ - 使模板化优化更易于维护，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/21589906/