C++模板学习笔记

一个有趣的东西：实现一个函数print, 输入一个数组, 输出数组的各个维度长度。

eg.
int a[], b[][], c[][][];
print(a);   //(2, 4)
print(b);   //(3, 16) (4, 4)
print(c);   //(5, 168) (6, 28) (7, 4)

template<typename T>
void print(const T &A) {
    printf("\n");
}
template<typename T, int N>
void print(const T (&A)[N]) {
    printf("(%d, %d) ", N, sizeof(A[]));
    print(A[]);
}

学习版块

https://github.com/wuye9036/CppTemplateTutorial  空明流转

typename与class

在 C++ Template 中很多地方都用到了 typename 与 class 这两个关键字，而且好像可以替换，是不是这两个关键字完全一样呢?
相信学习 C++ 的人对 class 这个关键字都非常明白，class 用于定义类，在模板引入 c++ 后，最初定义模板的方法为：
template<class T>......
这里 class 关键字表明T是一个类型，后来为了避免 class 在这两个地方的使用可能给人带来混淆，所以引入了 typename 这个关键字，它的作用同
class 一样表明后面的符号为一个类型，这样在定义模板的时候就可以使用下面的方式了：
template<typename
T>......
在模板定义语法中关键字 class 与 typename 的作用完全一样。
typename 难道仅仅在模板定义中起作用吗？其实不是这样，typename 另外一个作用为：使用嵌套依赖类型(nested depended name)，如下所示：
class MyArray
{
    public：
    typedef int LengthType;
.....
}

template<class T>
void MyMethod( T myarr )
{
    typedef typename T::LengthType LengthType;
    LengthType length = myarr.GetLength;
}
这个时候 typename 的作用就是告诉 c++ 编译器，typename 后面的字符串为一个类型名称，而不是成员函数或者成员变量，这个时候如果前面没有
typename，编译器没有任何办法知道 T::LengthType 是一个类型还是一个成员名称(静态数据成员或者静态函数)，所以编译不能够通过。

eg1.

 template <typename T> struct X {};
 template <typename T> struct Y
 {
     // X可以查找到原型；
     // X<T>是一个依赖性名称，模板定义阶段并不管X<T>是不是正确的。
     typedef X<T> ReboundType;

     // X可以查找到原型；
     // X<T>是一个依赖性名称，X<T>::MemberType也是一个依赖性名称；
     // 所以模板声明时也不会管X模板里面有没有MemberType这回事。
     typedef typename X<T>::MemberType MemberType2;

     // UnknownType 不是一个依赖性名称
     // 而且这个名字在当前作用域中不存在，所以直接报错。
     // typedef UnknownType MemberType3;    

     void foo()
     {
         X<T> instance0;
         typename X<T>::MemberType instance1;
     }
 };

eg2.

 struct A;
 template <typename T> struct B;
 template <typename T> struct X {
     typedef X<T> _A; // 编译器当然知道 X<T> 是一个类型。
     typedef X    _B; // X 等价于 X<T> 的缩写
     typedef T    _C; // T 不是一个类型还玩毛

     // ！！！注意我要变形了！！！
     class Y {
         typedef X<T>     _D;          // X 的内部，既然外部高枕无忧，内部更不用说了
         typedef X<T>::Y  _E;          // 嗯，这里也没问题，编译器知道Y就是当前的类型，
                                       // 这里在VS2015上会有错，需要添加 typename，
                                       // Clang 上顺利通过。
         typedef typename X<T*>::Y _F; // 这个居然要加 typename！
                                       // 因为，X<T*>和X<T>不一样哦，
                                       // 它可能会在实例化的时候被别的偏特化给抢过去实现了。
     };

     typedef A _G;                   // 嗯，没问题，A在外面声明啦
     typedef B<T> _H;                // B<T>也是一个类型
     typedef typename B<T>::type _I; // 嗯，因为不知道B<T>::type的信息，
                                     // 所以需要typename
     //typedef B<int>::type _J;        // B<int> 不依赖模板参数，
                                     // 所以编译器直接就实例化（instantiate）了
                                     // 但是这个时候，B并没有被实现，所以就出错了
 };

自己的理解：什么时候需要typename？如果编译器无法判断当前名称代表的是类型还是实例的时候，需要用typename来表示指代类型。如果遇到T::size_type * p; 无法知道是乘法运算还是定义指针。这时候，当我们希望通知编译器一个名字表示类型时，必须用关键字typename，而不是class。则为typename T::size_type *p;

============================分割线============================

引用折叠

引用折叠只能应用于间接创建的引用的引用，如类型别名或模板参数。

& &&，&& &，& &折叠后都是左值引用&; && &&折叠后是右值引用&&。

模板实参推断与引用

其中i是int，ci是const int.

template<typename T> void f1(T&); // 实参必须是左值，const属性得到保持

f1(i); //T是int

f1(ci); //T是const int

f1(5); //error, 必须是左值

template<typename T> void f2(const T&);  //可以接受右值

f2(i);

f2(ci);

f2(5); //以上T均为int

template<typename T> void f3(T&&); //实参为左值，T为左值引用；实参为const左值，T为const左值引用；实参为右值，T为右值引用

f3(i); //T是int&

f3(ci); //T是const int&

f3(5); //T是int&&

T&&，对应的const属性和左值/右值属性将得到保持。T&&可以实现转发，保持转发参数的所有性质，包括const和左右值。

移动与完美转发

std::move 如下.

/// remove_reference
template<typename _Tp>
struct remove_reference
{ typedef _Tp   type; };

template<typename _Tp>
struct remove_reference<_Tp&>
{ typedef _Tp   type; };

template<typename _Tp>
struct remove_reference<_Tp&&>
{ typedef _Tp   type; };

template <typename T>
typename remove_reference<T>::type&& move(T&& t) {
    return static_cast<typename remove_reference<T>::type&&>(t);
}

std::forward.

template <typename T>
T&& forward(typename remove_reference<T>::type& param)
{
    return static_cast<T&&>(param);
}

eg.

template<typename T>
void foo(T&& fparam)
{
    std::forward<T>(fprams);
}

int i = ;
foo(i);//T为int&，std::forward<T>(fprams)的类型为int & &&，折叠后为int &
foo();//T为int, std::forward<T>(fprams)的类型为int &&

//通过完美转发，可以简化代码，其中m_var1和m_var2是全局变量
void set(const string & var1, const string & var2) {
    //拷贝赋值
    m_var1 = var1;
    m_var2 = var2;
}
void set(string && var1, string && var2){
    //移动赋值
    m_var1 = std::move(var1);//move不能省略，具名变量都被当作左值
    m_var2 = std::move(var2);
}
//以上两个函数可以用以下函数代替
template<typename T1, typename T2>
void set(T1 && var1, T2 && var2){
    m_var1 = std::forward<T1>(var1);
    m_var2 = std::forward<T2>(var2);
}
//注：forward常用于template函数中，必须要多带一个参数forward<T>

可变参数函数模板(variadic function template)

主要使用了包扩展(pack expansion)的方式, 即"...",  把一个模式(pattern)扩展为包中每一个元素(element)的形式;

可变参数函数模板, 常使用递归(recursive)进行处理包(pack)参数,

需要一个非可变参数(nonvariadic)函数模板,结束递归, 当最后一次调用时, 调用非可变参数版本, 则递归结束;

还需要一个绑定(bing)的参数, 处理包(pack)中的一些元素, 通过递归,顺次处理包中的元素;

包扩展可以应用于各种形式, 如

函数的模板参数, 例如: templae<typename... Args>    扩展后即 template<typename Args1, typename Args2, typename Args3>

函数的参数模板, 例如: cosnt Args&... rest 扩展后即const Args& rest1, const Args& rest2, const Args& rest3

函数的形参, 例如: rest... 扩展后即rest1, rest2, rest3

函数模板, 例如: debug_rep(rest)...扩展后即debug_rep(rest1), debug_rep(rest2), debug_rep(rest3) //debug_rep是模板函数名

eg.

 #include <iostream>
 #include <sstream>  

 using namespace std;  

 //返回bug信息
 template <typename T>
 std::string debug_rep (const T& t)
 {
     std::ostringstream ret;
     ret << t;
     return ret.str();
 }  

 //非可变参数模板
 template<typename T>
 std::ostream &print(std::ostream &os, const T &t)
 {
     //std::cout << "This is nonvariadic function! ";
     return os << t;
 }  

 //可变参数模板, "..."是包扩展(Pack Expansion)
 template <typename T, typename... Args>
 std::ostream &print(std::ostream &os, const T &t, const Args&... rest)
 {
     os << t << ", ";
     return print(os, rest...);
 }  

 //函数模板的包扩展
 template <typename... Args>
 std::ostream &errorMsg(std::ostream &os, const Args&... rest)
 {
     return print(os, debug_rep(rest)...); //使用模板的包扩展
 }  

 int main()
 {
     int i(); std::string s("girls");
     //print(std::cout, i, s, 42);
     errorMsg(std::cout, i, s, , "ladies");  

     return ;
 }

C++11中的tuple就是可变参数类模板，在github找到了一份实现代码。(这个人好像还实现了好多别的东西，比如红黑树，堆排序，哈希表)

 #include <iostream>

 template<typename ... Types> class Tuple;
 template<> class Tuple<> {};
 template<typename First, typename ... Rest>
 class Tuple<First, Rest...>: private Tuple<Rest...> {
   First Member;
  public:
   Tuple(const First& first, const Rest& ... rest):
       Tuple<Rest...>(rest...), Member(first) {}

   const First& Head() const {
     return Member;
   }

   const Tuple<Rest...>& Tail() const {
     return *this;
   }
 };

 // As a return value of Get<>(Tuple) method is not a reference,
 // in order to make it available to return POD types.

 template<size_t I, class T>
 struct TupleElement;

 template<size_t I, class Head, class ... Rest>
 struct TupleElement<I, Tuple<Head, Rest...> >:
     public TupleElement<I - , Tuple<Rest...> > {
   static typename TupleElement<I, Tuple<Head, Rest...> >::Type
       Get(const Tuple<Head, Rest...>& t) {
     return TupleElement<I - , Tuple<Rest...> >::Get(t.Tail());
   }
 };

 template<class Head, class ... Rest>
 struct TupleElement<, Tuple<Head, Rest...> > {
   typedef Head Type;
   static typename TupleElement<, Tuple<Head, Rest...> >::Type
       Get(const Tuple<Head, Rest...>& t) {
     return t.Head();
   }
 };

 template<size_t Pos, class Head, class ... Rest>
 typename TupleElement<Pos, Tuple<Head, Rest...> >::Type
     Get(const Tuple<Head, Rest...>& t) {
   return TupleElement<Pos, Tuple<Head, Rest...> >::Get(t);
 }

 int main() {
   Tuple<int, double, char> t(, 3.14, 'a');
   std::cout << Get<>(t) << std::endl;
   std::cout << Get<>(t) << std::endl;
   std::cout << Get<>(t) << std::endl;
   return ;
 }

转发参数包

组合使用forward机制与可变参数模板实现转发参数包。《C++ primer 5th》16.4.3

============================分割线============================

模板元编程

(黑魔法：编译期间完成计算，如斐波那契，平方根等)

eg.斐波那契等

 #include <bits/stdc++.h>

 template<int N>
 struct Fac{
     static int const result = Fac<N->::result + Fac<N->::result;
 };
 template<>
 struct Fac<>{
     static int const result = ;
 };
 template<>
 struct Fac<>{
     static int const result = ;
 };
 /*
 推荐使用enum
 静态成员变量只能是左值
 如果遇到void foo(int const&);
 foo(Fac<7>::result);
 编译器将传递Fac<7>::result的地址,
 会强制编译期实例化静态成员的定义,
 并为该定义分配内存,
 于是该计算将不局限于完全的“编译期”效果
 而enum不是左值, 会以常量的形式传递参数
 以上抄自<<C++ template(中文版)>>P296
 */

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

 int main(){
     std::cout << Fac<>::result << std::endl;
     //std::cout << Fac<47>::result << std::endl; // without Fac<46>, compile error
     std::cout << Sum<>::result << std::endl;
     //std:cout << Sum<901>::result << std::endl; // without Sum<900>, compile error
     std::cout << Sum<>::result << std::endl; // OK
     //std::cout << Sum<1801>::result << std::endl; // without Sum<1800>, compile error
     return ;
 }

eg. Sqrt简易版本

 //easy版本, ：？条件表达式会同时实例化Sqrt<20, 0, 9>, Sqrt<20, 10, 20>
 #include <bits/stdc++.h>
 template<int N, int L = , int R = N>
 class Sqrt{
 public:
     enum{m = (L+R+) >> };
     enum{result = m*m > N? Sqrt<N, L, m->::result : Sqrt<N, m, R>::result};
 };
 template<int N, int L>
 class Sqrt<N, L, L>{
 public:
     enum{result = L};
 };

 int main(){
     std::cout << Sqrt<>::result;
     return ;
 }

tips：可以通过typedef+IfThenElse模板优化条件表达式

 #include <bits/stdc++.h>

 #ifndef IFTHENELSE
 #define IFTHENELSE
 template<bool C, typename Ta, typename Tb>
 class IfThenElse;

 //局部特化
 template<typename Ta, typename Tb>
 class IfThenElse<true, Ta, Tb>{
 public:
     typedef Ta Result;
 };
 template<typename Ta, typename Tb>
 class IfThenElse<false, Ta, Tb>{
 public:
     typedef Tb Result;
 };
 #endif

 template<int N, int L = , int R = N>
 class Sqrt{
 public:
     enum{m = (L+R+) >> };
     typedef typename IfThenElse<
         (m*m > N),
         Sqrt<N, L, m->,
         Sqrt<N, m, R>
     >::Result SubT;    //定义typedef不会实例化
     enum{result = SubT::result};
 };
 template<int N, int L>
 class Sqrt<N, L, L>{
 public:
     enum{result = L};
 };

 int main(){
     std::cout << Sqrt<>::result;
     return ;
 }

迭代版本

 #include <bits/stdc++.h>

 #ifndef IFTHENELSE
 #define IFTHENELSE
 template<bool C, typename Ta, typename Tb>
 class IfThenElse;

 //局部特化
 template<typename Ta, typename Tb>
 class IfThenElse<true, Ta, Tb>{
 public:
     typedef Ta Result;
 };
 template<typename Ta, typename Tb>
 class IfThenElse<false, Ta, Tb>{
 public:
     typedef Tb Result;
 };
 #endif

 template<int N>
 class Value{
 public:
     enum{result = N};
 };
 template<int N, int I = >
 class Sqrt{
 public:
     typedef typename IfThenElse<
         ((I+)*(I+) > N),
         Value<I>, //i, 特意构造一个Value类
         Sqrt<N, I+>
     >::Result SubT;

     enum{result = SubT::result};
 };

 int main(){
     std::cout << Sqrt<>::result;
     return ;
 }

未完待续