Template

首先，类模板定义

template<typename T> class MyTemplateClass{
    //在类模板自己的作用域中，可以直接使用模板名字而不提供实参，实参指的是`<typename T>`这种
    MyTemplateClass ret_func(const MyTemplateClass &customclass){
        return customclass;
    }
    //当实例化是T会被输入的实参而代替
    T cal_fun(T temp){
        return T*T;
    }
    //在类外定义，类内定义的函数时默认内联的
    T out_func(T temp);
};
//类外定义成员函数的写法
template<typename T> 
T MyTemplateClass<T>::cal_func(T temp){
    return T+T;
}

记住，仅仅时类的作用域内可以直接用名字例如上述模板类

//注意作用域外和作用域内
template<typename T>
MyTemplateClass<T> MyTemplateClass<T>::some_func(){
    MyTemplateClass ret = *this;
    return ret;
}

另类模板自己的类型参数成为友元

1
2
3

template<typename T> class Bar{
    friend T;
};

此时Foo成为Bar<Foo>的友元，Foo2成为Bar<Foo2>的友元
定义类模板别名：

1 2	template<typename T> using type_alias = Bar<T,T> //如此一来 type_alias<string>是一个Bar<string,string>

对于模板类的static来说，每一个实例都有自己的static。即对于给定类型X，Foo的静态成员才相互共享。 Q: static std::size_t ctr和

1 2	template<typename T> static size_t Foo<T>::ctr;

什么区别

模板声明 extern template class Blob<string> 其次,函数模板定义

template<typename T>
int compare(const &T t1,const &T t2){
    if t1 < t2 : return 1;
    if t1 > t2 : return -1;
}

#### 可变参数模板

template<typename T,typename... Args>       //模板参数包
void fun(const T &t,const Args& ...args){   //函数参数包
    //funtion
}

其中包扩展将包分解成构成它的元素 ```c++ template<Typename T,typename... Args> void func(const T&t,const Args& ...args){ return print(debug_rep(rest)...);//这样才是拓展，等价于debug_rep(args_1),debug_rep(args_2) //而debug_rep(rest...)是错误写法，这意味着给debug_rep传递了所有的rest的构成参数 }

Forward是一个可以保持原始实参的类型，通过forward进行函数实参的调用就能很爽，std::forward(t1)