万字长文，这是我见过最好的模板元编程文章了！

-0 -0.707107 -1.1547 -1.5 -1.78885 -2.04124 -2.26779 -2.47487 -2.66667 -2.84605

#include  // std::cout#include  // std::sqrt()
void evaluate(double start, double end, double step) { double _temp = 1.0; for(double i=start; i std::cout << -i / std::sqrt(_temp + i) << ' ';}
int main() { evaluate(0.0, 10.0, 1.0); std::cin.get(); return 0;}

-0 -0.707107 -1.1547 -1.5 -1.78885 -2.04124 -2.26779 -2.47487 -2.66667 -2.84605

class DoubleVec; // DoubleVec 重载了 + - * / 等向量元素之间的计算DoubleVec y(1000), a(1000), b(1000), c(1000), d(1000); // 向量长度 1000// 向量计算y = (a + b) / (c - d);// 等价于DoubleVec __t1 = a + b;DoubleVec __t2 = c - d;DoubleVec __t3 = __t1 / __t2;y = __t3;

// 模板基类，定义接口，具体实现由模板参数，即子类实现template <typename D>class base {public: void f1() { static_cast(*this).f1(); } // 直接调用子类实现 int f2() const { static_cast<const E&>(*this).f1(); }};// 子类class dirived1 : public base {public: void f1() { /* ... */ } int f2() const { /* ... */ }};template<typename T>class dirived2 : public base> {public: void f1() { /* ... */ } int f2() const { /* ... */ }};

#include  // std::cout
// A CRTP base class for Vecs with a size and indexing:template class VecExpr {public: double operator[](int i) const { return static_castconst&>(*this)[i]; } operator E const&() const { return static_cast<const E&>(*this); } // 向下类型转换};// The actual Vec class:class Vec : public VecExpr<Vec> { double _data[1000];public: double& operator[](int i) { return _data[i]; } double operator[](int i) const { return _data[i]; } template  Vec const& operator=(VecExpr const& vec) { E const& v = vec; for (int i = 0; i<1000; ++i) _data[i] = v[i]; return *this; }// Constructors Vec() { } Vec(double v) { for(int i=0; i<1000; ++i) _data[i] = v; }};
template class VecDifference : public VecExpr<VecDifference> > { E1 const& _u; E2 const& _v;public: VecDifference(VecExpr const& u, VecExpr const& v) : _u(u), _v(v) { } double operator[](int i) const { return _u[i] - _v[i]; }};template class VecScaled : public VecExpr<VecScaled> > { double _alpha; E const& _v;public: VecScaled(double alpha, VecExpr const& v) : _alpha(alpha), _v(v) { } double operator[](int i) const { return _alpha * _v[i]; }};
// Now we can overload operators:template  VecDifference constoperator-(VecExpr const& u, VecExpr const& v) { return VecDifference(u, v);}template  VecScaled constoperator*(double alpha, VecExpr const& v) { return VecScaled(alpha, v);}
int main() { Vec u(3), v(1); double alpha=9; Vec y; y = alpha*(u - v); std::cout << y[999] << '\n'; std::cin.get(); return 0;}

18

#include  // std::cout#include 
template<typename iter>typename iter::value_type mysum(iter begin, iter end) { typename iter::value_type sum(0); for(iter i=begin; i!=end; ++i) sum += *i; return sum;}
int main() { std::vector<int> v; for(int i = 0; i<100; ++i) v.push_back(i); std::cout << mysum(v.begin(), v.end()) << '\n'; std::cin.get(); return 0;}

4950

// 特性，traitstemplate<typename iter>class mytraits{public: typedef typename iter::value_type value_type;};template<typename T>class mytraits{public: typedef T value_type;};
template<typename iter>typename mytraits::value_type mysum(iter begin, iter end) { typename mytraits::value_type sum(0); for(iter i=begin; i!=end; ++i) sum += *i; return sum;}
int main() { int v[4] = {1,2,3,4}; std::cout << mysum(v, v+4) << '\n'; std::cin.get(); return 0;}

10

#include #include 
template<typename T1, typename T2> // 通例，返回 falseclass theSameType { public: enum { ret = false }; };template<typename T> // 特例，两类型相同时返回 trueclass theSameType { public: enum { ret = true }; };
int main(){ std::cout << theSameType< std::vector<int>::iterator::iterator_category, std::random_access_iterator_tag >::ret << '\n'; std::cin.get(); return 0;}

1

#include  // std::cout
// whether T could be converted to Utemplate<class T, class U>class ConversionTo { typedef char Type1[1]; // 两种 sizeof 不同的类型 typedef char Type2[2]; static Type1& Test( U ); // 较下面的函数，因为参数取值范围小，优先匹配 static Type2& Test(...); // 变长参数函数，可以匹配任何数量任何类型参数 static T MakeT(); // 返回类型 T，用这个函数而不用 T() 因为 T 可能没有默认构造函数 public: enum { ret = sizeof(Test(MakeT()))==sizeof(Type1) }; // 可以转换时调用返回 Type1 的 Test()};
int main() { std::cout << ConversionTo<int, double>::ret << '\n'; std::cout << ConversionTo<float, int*>::ret << '\n'; std::cout << ConversionTo<const int&, int&>::ret << '\n'; std::cin.get(); return 0;}

100

#include #include 
// thanks to Substitution failure is not an erro (SFINAE)template<typename T>struct has_typedef_value_type { typedef char Type1[1]; typedef char Type2[2]; template<typename C> static Type1& test(typename C::value_type*); template<typename> static Type2& test(...);public: static const bool ret = sizeof(test(0)) == sizeof(Type1); // 0 == NULL};
struct foo { typedef float lalala; };
int main() { std::cout << has_typedef_value_type<std::vector<int>>::ret << '\n'; std::cout << has_typedef_value_type::ret << '\n'; std::cin.get(); return 0;}

10

#include 
class null_type {}; // 标签类，标记参数列表末尾template<typename T0, typename T1, typename T2, typename T3>class type_shift_node {public: typedef T0 data_type; typedef type_shift_node next_type; // 参数移位了 static const int num = next_type::num + 1; // 非 null_type 模板参数个数 data_type data; // 本节点数据 next_type next; // 后续所有节点数据 type_shift_node() :data(), next() { } // 构造函数 type_shift_node(T0 const& d0, T1 const& d1, T2 const& d2, T3 const& d3) :data(d0), next(d1, d2, d3, null_type()) { } // next 参数也移位了};template<typename T0> // 特例，递归终止class type_shift_node {public: typedef T0 data_type; static const int num = 1; data_type data; // 本节点数据 type_shift_node() :data(), next() { } // 构造函数 type_shift_node(T0 const& d0, null_type, null_type, null_type) : data(d0) { }};// 元组类模板，默认参数 + 嵌套递归template<typename T0, typename T1=null_type, typename T2=null_type, typename T3=null_type>class my_tuple {public: typedef type_shift_node tuple_type; static const int num = tuple_type::num; tuple_type t; my_tuple(T0 const& d0=T0(),T1 const& d1=T1(),T2 const& d2=T2(),T3 const& d3=T3()) : t(d0, d1, d2, d3) { } // 构造函数，默认参数};
// 为方便访问元组数据，定义 get(tuple) 函数模板template<unsigned i, typename T0, typename T1, typename T2, typename T3>class type_shift_node_traits {public: typedef typename type_shift_node_traits-1,T0,T1,T2,T3>::node_type::next_type node_type; typedef typename node_type::data_type data_type; static node_type& get_node(type_shift_node& node){ return type_shift_node_traits-1,T0,T1,T2,T3>::get_node(node).next; }};template<typename T0, typename T1, typename T2, typename T3>class type_shift_node_traits<0, T0, T1, T2, T3> {public: typedef typename type_shift_node node_type; typedef typename node_type::data_type data_type; static node_type& get_node(type_shift_node& node){ return node; }};template<unsigned i, typename T0, typename T1, typename T2, typename T3>typename type_shift_node_traits::data_typeget(my_tuple& tup) { return type_shift_node_traits::get_node(tup.t).data;}
int main(){ typedef my_tuple<int, char, float> tuple3; tuple3 t3(10, 'm', 1.2f); std::cout << t3.t.data << ' ' << t3.t.next.data << ' ' << t3.t.next.next.data << '\n'; std::cout << tuple3::num << '\n'; std::cout << get<2>(t3) << '\n'; // 从 0 开始，不要出现 3，否则将出现不可理解的编译错误 std::cin.get(); return 0;}

10 m 1.231.2

#include 
// 元容器template<typename T0=void, typename T1=void, typename T2=void, typename T3=void>class meta_container {public: typedef T0 type; typedef meta_containervoid> next_node; // 参数移位了 static const int size = next_node::size + 1; // 非 null_type 模板参数个数};template<> // 特例，递归终止class meta_container {public: typedef void type; static const int size = 0;};
// 访问元容器中的数据template<typename C, unsigned i>class get {public: static_assert(i"get: index exceed num"); // C++11 引入静态断言 typedef typename get-1>::c_type::next_node c_type; typedef typename c_type::type ret_type;};template<typename C>class get {public: static_assert(0"get: index exceed num"); // C++11 引入静态断言 typedef C c_type; typedef typename c_type::type ret_type;};
// 在元容器中查找某个类型，找到返回索引，找不到返回 -1template<typename T1, typename T2> class same_type { public: enum { ret = false }; };template<typename T> class same_type { public: enum { ret = true }; };
template<bool c, typename Then, typename Else> class IF_ { };template<typename Then, typename Else>class IF_ { public: typedef Then reType; };template<typename Then, typename Else>class IF_ { public: typedef Else reType; };
template<typename C, typename T>class find { template<int i> class number { public: static const int ret = i; }; template<typename C, typename T, int i> class find_i { public: static const int ret = IF_< same_type::ret_type, T>::ret, number, find_i-1> >::reType::ret; }; template<typename C, typename T> class find_i { public: static const int ret = -1; };public: static const int ret = find_i-1>::ret;};
int main(){ typedef meta_container<int, int&, const int> mc; int a = 9999; get1>::ret_type aref = a; std::cout << mc::size << '\n'; std::cout << aref << '\n'; std::cout << findconst int>::ret << '\n'; std::cout << findfloat>::ret << '\n'; std::cin.get(); return 0;}