C++模板元编程（C++ template metaprogramming）

#include <iostream>

 

template<typename T, int i=1>

class someComputing {

public:

    typedef volatile T* retType; // 类型计算

    enum { retValume = i + someComputing<T, i-1>::retValume }; // 数值计算，递归

    static void f() { std::cout << "someComputing: i=" << i << '\n'; }

};

template<typename T> // 模板特例，递归终止条件

class someComputing<T, 0> {

public:

    enum { retValume = 0 };

};

 

template<typename T>

class codeComputing {

public:

    static void f() { T::f(); } // 根据类型调用函数，代码计算

};

 

int main(){

    someComputing<int>::retType a=0;

    std::cout << sizeof(a) << '\n'; // 64-bit 程序指针

    // VS2013 默认最大递归深度500，GCC4.8 默认最大递归深度900（-ftemplate-depth=n）

    std::cout << someComputing<int, 500>::retValume << '\n'; // 1+2+...+500

    codeComputing<someComputing<int, 99>>::f();

    std::cin.get(); return 0;

}

8

125250

someComputing: i=99

// Prime number computation by Erwin Unruh

template<int i> struct D { D(void*); operator int(); }; // 构造函数参数为 void* 指针

 

template<int p, int i> struct is_prime { // 判断 p 是否为素数，即 p 不能整除 2...p-1

    enum { prim = (p%i) && is_prime<(i>2?p:0), i-1>::prim };

};

template<> struct is_prime<0, 0> { enum { prim = 1 }; };

template<> struct is_prime<0, 1> { enum { prim = 1 }; };

 

template<int i> struct Prime_print {

    Prime_print<i-1> a;

    enum { prim = is_prime<i, i-1>::prim };

    // prim 为真时， prim?1:0 为 1，int 到 D<i> 转换报错；假时， 0 为 NULL 指针不报错

    void f() { D<i> d = prim?1:0; a.f(); } // 调用 a.f() 实例化 Prime_print<i-1>::f()

};

template<> struct Prime_print<2> { // 特例，递归终止

    enum { prim = 1 };

    void f() { D<2> d = prim?1:0; }

};

 

#ifndef LAST

#define LAST 10

#endif

 

int main() {

    Prime_print<LAST> a; a.f(); // 必须调用 a.f() 以实例化 Prime_print<LAST>::f()

}

#include <iostream>

 

template<int N>

class sumt{

public: static const int ret = sumt<N-1>::ret + N;

};

template<>

class sumt<0>{

public: static const int ret = 0;

};

 

int main() {

    std::cout << sumt<5>::ret << '\n';

    std::cin.get(); return 0;

}

// 通例为空，若不匹配特例将报错，很好的调试手段（这里是 bool 就无所谓了）

template<bool c, typename Then, typename Else> class IF_ { };

template<typename Then, typename Else>

class IF_<true, Then, Else> { public: typedef Then reType; };

template<typename Then, typename Else>

class IF_<false,Then, Else> { public: typedef Else reType; };

 

// 隐含要求： Condition 返回值 ret，Statement 有类型 Next

template<template<typename> class Condition, typename Statement>

class WHILE_ {

    template<typename Statement> class STOP { public: typedef Statement reType; };

public:

    typedef typename

        IF_<Condition<Statement>::ret,

        WHILE_<Condition, typename Statement::Next>,

        STOP<Statement>>::reType::reType

    reType;

};

const int len = 4;

typedef

    IF_<sizeof(short)==len, short,

    IF_<sizeof(int)==len, int,

    IF_<sizeof(long)==len, long,

    IF_<sizeof(long long)==len, long long,

    void>::reType>::reType>::reType>::reType

int_my; // 定义一个指定字节数的类型

std::cout << sizeof(int_my) << '\n';

4

// 计算 1^e+2^e+...+n^e

template<int n, int e>

class sum_pow {

    template<int i, int e> class pow_e{ public: enum{ ret=i*pow_e<i,e-1>::ret }; };

    template<int i> class pow_e<i,0>{ public: enum{ ret=1 }; };

    // 计算 i^e，嵌套类使得能够定义嵌套模板元函数，private 访问控制隐藏实现细节

    template<int i> class pow{ public: enum{ ret=pow_e<i,e>::ret }; };

    template<typename stat>

    class cond { public: enum{ ret=(stat::ri<=n) }; };

    template<int i, int sum>

    class stat { public: typedef stat<i+1, sum+pow<i>::ret> Next;

                         enum{ ri=i, ret=sum }; };

public:

    enum{ ret = WHILE_<cond, stat<1,0>>::reType::ret };

};

 

int main() {

    std::cout << sum_pow<10, 2>::ret << '\n';

    std::cin.get(); return 0;

}

385

int lcm(int a, int b){

    int r, lcm=a*b;

    while(r=a%b) { a = b; b = r; } // 因为用可变的存储，不能写成 a=b; b=a%b;

    return lcm/b;

}

// 递归函数版本

int gcd_r(int a, int b) { return b==0 ? a : gcd_r(b, a%b); } // 简洁

int lcm_r(int a, int b) { return a * b / gcd_r(a,b); }

 

// 模板版本

template<int a, int b>

class lcm_T{

    template<typename stat>

    class cond { public: enum{ ret=(stat::div!=0) }; };

    template<int a, int b>

    class stat { public: typedef stat<b, a%b> Next; enum{ div=a%b, ret=b }; };

    static const int gcd = WHILE_<cond, stat<a,b>>::reType::ret;

public:

    static const int ret = a * b / gcd;

};

// 递归模板版本

template<int a, int b>

class lcm_T_r{

    template<int a, int b> class gcd { public: enum{ ret = gcd<b,a%b>::ret }; };

    template<int a> class gcd<a, 0> { public: enum{ ret = a }; };

public:

    static const int ret = a * b / gcd<a,b>::ret;

};

 

int main() {

    std::cout << lcm(100, 36) << '\n';

    std::cout << lcm_r(100, 36) << '\n';

    std::cout << lcm_T<100, 36>::ret << '\n';

    std::cout << lcm_T_r<100, 36>::ret << '\n';

    std::cin.get(); return 0;

}

900

900

900

900