这段代码的原理是什么

apple753357

#include <iostream>

template<int N>
struct sum {
    enum {result = sum<N-1>::result + N };
};

template<>
struct sum<1> {
   enum{result = 1};
};


int main (int argc, char *argv[]) {
    std::cout << sum<10>::result << std::endl;
    return 0;
}

OwnWaterloo

编译器遇见：
std::cout << sum<10>::result << std::endl;

中的sum<10>，就会去实例化这个类模板。

由类模板定义：
enum {result = sum<N-1>::result + N };
sum<10> 又会实例化sum<9>

sum<9> 会继续实例化sum<8>

直到sum<2>
enum { result = sum<1>::result + 2 };

而sum<1>有偏特化版本：
template<>
struct sum<1> {
   enum{result = 1};
};

递归终止，得到结果sum<10>::result = 55;

zpp71

就是在编译阶段实现递归。

apple753357

这种依赖编译期的c＋＋代码编写方式有什么用吗？

baopbird2005

学习

rollin7

学习一下，还没这么用过

OwnWaterloo

原帖由 apple753357 于 2009-7-17 00:32 发表
这种依赖编译期的c＋＋代码编写方式有什么用吗？

这种用法有时候被称为模板元编程（template meta programming）。
利用编译器对模板实例化进行编程工作， 编程的结果本身就作为另一个程序。

例子嘛……  比如一个题目， 解析完题意就是，输入n ( 1 <= n <= 10 )，输出 n!。

按照常规也可以运行时计算：

---- factorial.cpp ----

int factorial(int n) { ... }

int main(void) {
    int n = 0;
    scanf("%d",&n);
    printf("%d\n",factorial(n));
}


要更快一点么，  显然就是做一个表， 直接查：

---- factorial.cpp ----
static const int factorials[]  = {
   // 这里怎么计算表？
};

int main(void) {
    int n = 0;
    scanf("%d",&n);
    printf("%d\n",factorials[n] );
}


表的计算那里可以用计算器算出来， 然后填……

也可以由另外一个程序生成：
---- generating.cpp ----
int main(void) {    for (int i=0,j=1;i<=10,++i,j*=i) printf("    %d,\n",j); }

generating.exe > 1.txt
然后复制到factorial.cpp中， factorial.cpp 再编译为程序。

而模板元编程可以直接在一个cpp中完成这个事情。

template<int n>
struct factorial { enum { value = factorial<n-1>::value * n }; };

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

static const int factorials[] = {
    factorial<0>::value,
    factorial<1>::value,
    // ...
    factorial<10>::value,
};

[ 本帖最后由 OwnWaterloo 于 2009-7-17 14:45 编辑 ]