模板（元）编程是否总是只有一种实现方式？

Question

研究了少数template 程序，尤其是将编译时结果推导出为常数的元程序，我了解到通常只有一种方法可以实现某物。例如：像factorial 示例一样简单或像is_base_of 一样复杂

我永远无法考虑完全不同逻辑的代码的完美替代实现。这是一个真实的假设吗？

如果这个假设是正确的，这意味着，无论何时我们使用模板技巧来实现某些东西，我们总是可以确信，这是最好的代码，我们不必再担心优化编译时间了。

[注意：我没有提到我们对class 和函数所做的一般template 用法。但是用于推导编译时间常数的用法。]

Answer 1

您倾向于只看到一种做事方式的原因是，人们实际使用模板元编程的事情通常在算法上是微不足道的——它们只是看起来很复杂，因为它们与大量的黑客行为和C++ 模板语法的怪异之处。

但有时（正如史蒂夫·杰索普的回答所示）确实有多种算法可以计算某些东西，您可以使用模板来实现其中的任何一种。

作为另一个例子，这里有两种方法来评估pow(a,b)（对于小整数参数）：

很明显：

// ----- Simple Way -----

template <int A, int B>
struct PowA {
    typedef PowA<A,B-1> next;
    enum {
       value = A * next::value,
       recursion_count = 1 + next::recursion_count
    };
};
template <int A> struct PowA<A, 1> { enum { value = A, recursion_count = 0 }; };
template <int A> struct PowA<A, 0> { enum { value = 1, recursion_count = 0 }; };

Slightly less obvious:

// ----- Less Simple Way -----

template <int A, int B, int IsOdd> struct PowHelper;

template <int A> struct PowHelper<A, 0, 0> { enum { value = 1, recursion_count = 0 }; };
template <int A> struct PowHelper<A, 1, 1> { enum { value = A, recursion_count = 0 }; };

template <int A, int B>
struct PowHelper<A, B, 1> {
    typedef PowHelper<A, B-1, 1> next;
    enum {
        value = A * next::value,
        recursion_count = 1 + next::recursion_count
    };
};
template <int A, int B>
struct PowHelper<A, B, 0> {
    typedef PowHelper<A, B/2, ((B/2)&1)> next;
    enum {
        x = next::value,
        value = x*x,
        recursion_count = 1 + next::recursion_count
    };
};

template <int A, int B>
struct PowB {
    typedef PowHelper<A,B,(B & 1)> helper;
    enum {
        value = helper::value,
        recursion_count = helper::recursion_count
    };
};

还有一些代码让你检查一下：

// ----- Test -----

#include <iostream>

int main(int argc, char* argv[]) {
#define CHECK(X,Y) \
    std::cout << ("PowA: " #X "**" #Y " = ") << \
        PowA<(X),(Y)>::value << " (recurses " << \
        PowA<(X),(Y)>::recursion_count << " times)" << std::endl; \
    std::cout << ("PowB: " #X "**" #Y " = ") << \
        PowB<(X),(Y)>::value << " (recurses " << \
        PowB<(X),(Y)>::recursion_count << " times)" << std::endl;

    CHECK(3,3)
    CHECK(2,8)
    CHECK(7,3)
    CHECK(3,18)

#undef CHECK

   return 0;
}

Answer 2

有点取决于您所说的“以不同的方式做事”是什么意思。以下是计算三角形数的两种 TMP 实现：

template<int N>
struct RecursiveTriangle {
    static const int value = RecursiveTriangle<N-1>::value + N;
};

template<>
struct RecursiveTriangle<0> {
    static const int value = 0;
};

template<int N>
struct Triangle {
    static const int value = (N*(N+1))/2;
};

这些恰好类似于两种“不同”的命令式计算三角形数的方法——使用循环或使用与Triangle 相同的公式。不过，它们的定义域不同 - Triangle 处理负数，而 RecursiveTriangle 不处理。并不是说Triangle 的负数结果很有意义。

那么，“不同的方法”是什么意思？

Answer 3

一般而言，TMP 中缺乏可用的功能以及功能的相对简单性（如果不是必须表达的方式）意味着很少有多个实现存在显着差异 .

Answer 4

让我们从Wikipedia获取factorial的代码：

template <int N>
struct Factorial 
{
    enum { value = N * Factorial<N - 1>::value };
};

template <>
struct Factorial<0> 
{
    enum { value = 1 };
};

你也可以这样实现：

template <int N>
struct Factorial 
{
    enum { value = Factorial<N - 1>::value * N };
};

template <>
struct Factorial<0> 
{
    enum { value = 1 };
};

或者作为：

template <int N>
struct Factorial 
{
    enum { value = N * Factorial<N - 1>::value };
};

template <>
struct Factorial<1> 
{
    enum { value = 1 };
};

template <>
struct Factorial<0> 
{
    enum { value = 1 };
};

Answer 5

不，不只有一种实现。以下是两种执行阶乘的示例：

#include <iostream>
using namespace std;

template <int N>
struct Factorial
{
  enum { value = N * Factorial<N - 1>::value };
};

template <>
struct Factorial<0>
{
  enum { value = 1 };
};

template <int N>
class FactorialC {
public:
  static const long value = N * Factorial<N - 1>::value;
};

template <>
class FactorialC<10> {
public:
  static const long value = 3628800;
};

template <>
class FactorialC<0> {
public:
  static const long value = 0;
};

int main() {
  cout << Factorial<4>::value << endl;
  cout << Factorial<12>::value << endl;
  cout << FactorialC<4>::value << endl;
  cout << FactorialC<12>::value << endl;
}

输出：

24
479001600
24
479001600