编译时的编程机制

1.阶乘

template<int n> class Factorial{
public:
    enum{
        val=Factorial<n-1>::val*n
    };
};
template<> class Factorial<0>{
public:
    enum{
        val=1   
    };
};
Factorial<>::val;       //120

2.斐波那契数列

template<int n> class Fib{
public:
    enum{
        val=Fib<n-1>::val+Fib<n-2>::val
    };
};
template<> class Fib<1>{
public:
    enum{
        val=1   
    };
};
template<> class Fib<0>{
public:
    enum{
        val=0   
    };
};
Fib<5>::val;        //5

3.N的P次方

template<int N,int P> class Power{
public:
    enum{
        val=N*Power<N,P-1>::val
    };
};
template<int N> class Power<N,0>{
public:
    enum{
        val=1
    };
};
Power<2,5>::val;        //32

4.f(n)+f(n-1)….f(0)

template<int n, template<int> typename F> class Accumulate {
public:
    enum {
        val=Accumulate<n-1,F>::val+F<n>::val
    };
};
template<template<int> typename F> class Accumulate<0, F> {
public:
    enum {
        val=F<0>::val
    };
};
template<int n> class Identity {
public:
    enum {
        val=n
    };
};
Accumulate<4, Identity>::val;       //10

5.循环分解，整数幂

template<int n> inline int power(int m){
    return power<n-1>(m)*m;
};
template<> inline int power<1>(int m){
    return m;
};
template<> inline int power<0>(int m){
    return 1;
};
power<3>(4);        //64

6.编译时的条件选择：最大值

template<int n1,int n2> class Max{
    enum{
        val=n1>n2?n1:n2
    };
};
Max<10,20>::val;        //20

7.表达式模板

template<class, std::size_t> class MyVectorSum;
template<typename T, std::size_t N> class MyVector {
private:
    T data[N];
public:
    MyVector<T, N> &operator=(const MyVector<T, N> &right) {
        for (std::size_t i = 0; i < N; ++i) {
            data[i] = right.data[i];
        }
        return *this;
    }
    MyVector<T, N> &operator=(const MyVectorSum<T, N> &right);
    const T &operator[](std::size_t i) const {
        return data[i];
    }
    T &operator[](std::size_t i) {
        return data[i];
    }
};
template<typename T, std::size_t N> class MyVectorSum {
private:
    const MyVector<T, N> &left;
    const MyVector<T, N> &right;
public:
    MyVectorSum(const MyVector<T,N> &lhs,const MyVector<T,N> &rhs):left(lhs),right(rhs){}
    T operator[](std::size_t i) const {
        return left[i] + right[i];
    }
};
template<typename T, std::size_t N> 
MyVector<T, N> &MyVector<T, N>::operator=(const MyVectorSum<T, N> &right) {
    for (std::size_t i = 0; i < N; ++i) {
        data[i] = right[i];
    }
    return *this;
}
template<typename T,std::size_t N> 
inline MyVectorSum<T, N> operator+(const MyVector<T, N> &left, const MyVector<T, N> &right) {
    return MyVectorSum<T, N>(left, right);
}
template<typename T,std::size_t N>
void init(MyVector<T, N> &v) {
    for (std::size_t i = 0; i < N; ++i) {
        v[i] = rand() % 100;
    }
}
template<typename T, std::size_t N> 
void print(MyVector<T, N> &v) {
    for (std::size_t i = 0; i < N; ++i) {
        std::cout << v[i] << ' ';
    }
    std::cout << endl;
}

void main() {
    srand(time(0));
    MyVector<int, 5> v1;
    init(v1);
    print(v1);
    MyVector<int, 5> v2;
    init(v2);
    print(v2);
    MyVector<int, 5> v3;
    init(v3);
    print(v3);
    v3.operator=(MyVectorSum<int, 5>(v2, v3));
}