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

#include <iostream>

 

// 函数模板

template<typename T>

bool equivalent(const T& a, const T& b){

    return !(a < b) && !(b < a);

}

// 类模板

template<typename T=int> // 默认参数

class bignumber{

    T _v;

public:

    bignumber(T a) : _v(a) { }

    inline bool operator<(const bignumber& b) const; // 等价于 (const bignumber<T> b)

};

// 在类模板外实现成员函数

template<typename T>

bool bignumber<T>::operator<(const bignumber& b) const{

    return _v < b._v;

}

 

int main()

{

    bignumber<> a(1), b(1); // 使用默认参数，"<>"不能省略

    std::cout << equivalent(a, b) << '\n'; // 函数模板参数自动推导

    std::cout << equivalent<double>(1, 2) << '\n';

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

}

// 实现一个向量类

template<typename T, int N>

class Vec{

    T _v[N];

    // ... // 模板通例（primary template），具体实现

};

template<>

class Vec<float, 4>{

    float _v[4];

    // ... // 对 Vec<float, 4> 进行专门实现，如利用向量指令进行加速

};

template<int N>

class Vec<bool, N>{

    char _v[(N+sizeof(char)-1)/sizeof(char)];

    // ... // 对 Vec<bool, N> 进行专门实现，如用一个比特位表示一个bool

};

template<typename T, int i> class cp00; // 用于模板型模板参数

// 通例

template<typename T1, typename T2, int i, template<typename, int> class CP>

class TMP;

// 完全特例化

template<>

class TMP<int, float, 2, cp00>;

// 第一个参数有const修饰

template<typename T1, typename T2, int i, template<typename, int> class CP>

class TMP<const T1, T2, i, CP>;

// 第一二个参数为cp00的实例且满足一定关系，第四个参数为cp00

template<typename T, int i>

class TMP<cp00<T, i>, cp00<T, i+10>, i, cp00>;

// 编译错误!，第四个参数类型和通例类型不一致

//template<template<int i> CP>

//class TMP<int, float, 10, CP>;

#include <iostream>

// 识别两个类型是否相同，提前进入模板元编程^_^

template<typename T1, typename T2> // 通例，返回 false

class theSameType       { public: enum { ret = false }; };

template<typename T>               // 特例，两类型相同时返回 true

class theSameType<T, T> { public: enum { ret = true }; };

 

template<typename T, int i> class aTMP { };

 

int main(){

    typedef unsigned int uint; // typedef 定义类型别名而不是引入新类型

    typedef uint uint2;

    std::cout << theSameType<unsigned, uint2>::ret << '\n';

    // 感谢 C++11，连续角括号“>>”不会被当做流输入符号而编译错误

    std::cout << theSameType<aTMP<unsigned, 2>, aTMP<uint2, 2>>::ret << '\n';

    std::cout << theSameType<aTMP<int, 2>, aTMP<int, 3>>::ret << '\n';

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

}

1

1

0

#include <iostream>

 

template<typename T>

class aTMP {

public:

    void f1() { std::cout << "f1()\n"; }

    void f2() { std::ccccout << "f2()\n"; } // 敲错键盘了，语义错误：没有 std::ccccout

};

 

int main(){

    aTMP<int> a;

    a.f1();

    // a.f2(); // 这句代码被注释时，aTMP<int>::f2() 不被实例化，从而上面的错误被掩盖!

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

}

#include <iostream>

 

// 计算 N 的阶乘 N!

template<int N>

class aTMP{

public:

    enum { ret = N * aTMP<N-1>::ret };

};

template<>

class aTMP<0>{

public:

    enum { ret = 1 };

};

 

int main(){

    std::cout << aTMP<10>::ret << '\n';

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

}

3228800

// file: a.cpp

#include <iostream>

template<typename T>

class MyClass { };

template MyClass<double>::MyClass(); // 显示实例化构造函数 MyClass<double>::MyClass()

template class MyClass<long>;        // 显示实例化整个类 MyClass<long>

 

template<typename T>

void print(T const& m) { std::cout << "a.cpp: " << m << '\n'; }

 

void fa() {

    print(1);   // print<int>，隐式实例化

    print(0.1); // print<double>

}

void fb(); // fb() 在 b.cpp 中定义，此处声明

 

int main(){

    fa();

    fb();

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

}

// file: b.cpp

#include <iostream>

template<typename T>

void print(T const& m) { std::cout << "b.cpp: " << m << '\n'; }

 

void fb() {

    print('2'); // print<char>

    print(0.1); // print<double>

}

1

2

3

4

a.cpp: 1

a.cpp: 0.1

b.cpp: 2

a.cpp: 0.1

#include <iostream>

 

template<typename T>

class aTMP{

public: typedef const T reType;

};

 

void f() { std::cout << "global f()\n"; }

 

template<typename T>

class Base {

public:

    template <int N = 99>

    void f() { std::cout << "member f(): " << N << '\n'; }

};

 

template<typename T>

class Derived : public Base<T> {

public:

    typename T::reType m; // typename 不能省略

    Derived(typename T::reType a) : m(a) { }

    void df1() { f(); }                       // 调用全局 f()，而非想象中的基类 f()

    void df2() { this->template f(); }        // 基类 f<99>()

    void df3() { Base<T>::template f<22>(); } // 强制基类 f<22>()

    void df4() { ::f(); }                     // 强制全局 f()

};

 

int main(){

    Derived<aTMP<int>> a(10);

    a.df1(); a.df2(); a.df3(); a.df4();

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

}

global f()

member f(): 99

member f(): 22

global f()