1
template<typename T, typename... Args>
2
vector<T> func(const Args&... args){
3
    return {args...};
4
}
5
int main(){
6
    auto vec = func<int>(1,2,3,4,5,6,7);
7
    for(auto& i:vec){
8
        cout << i << endl;
9
    }
10
}
11
/*
12
输出：
13
1
14
2
15
3
16
4
17
5
18
6
19
7
20
*/

1
template <typename... Args>
2
void FormatPrint(const Args&... args)
3
{
4
   std::initializer_list<int>{ (std::cout << "[" << args << "]", 0)...};
5
   std::cout << std::endl;
6
}

1
int main()
2
{
3
   FormatPrint(1, 2, 3, 4);
4
   FormatPrint("good", 2, "hello", 4, 110);
5
   return 0;
6
}

1
template<typename T>
2
void print (T arg){
3
    cout << arg << endl;
4
}
5
template<typename T, typename... Args>
6
void print (T firstArg, Args... args)
7
{
8
    print(firstArg); //注意这里。这里调用了无模板参数包的函数。单独打印这次解包出来的这一个变量。
9
    print(args...); // call print() for remaining arguments
10
}
11
int main()
12
{
13
    print(1, 1000, "b23", 1.123, "HahaahaH", 42);
14
    return 0;
15
}

1
template<typename T, typename... Args>
2
void print (T firstArg, Args... args)
3
{
4
    print(firstArg);
5
    cout << "remains"<<sizeof...(args) << endl; //函数参数包
6
    cout << "remains"<<sizeof...(Args) << endl; //模板参数包
7
    print(args...);
8
}

1
template<typename... Args>
2
void print(Args... args){
3
    (print(args), ...); //这里外部一定要加括号。注意语法
4
    (..., print(args));//??
5
}

1
print(1), print(1000), print("b23"),.....;

1
template<typename T> //要有单参打印的重载。不然会无限调用。
2
void print(T t){
3
    cout << t << endl;
4
}
5

6

7
template<typename... Args>
8
void print(Args... args){
9
    (print(args), ...); //这里外部一定要加括号。注意语法。这里的,是逗号运算符。
10
}
11

12

13
template<typename... T>
14
void printDoubled (T const&... args)
15
{
16
    print (args + args...);
17
}
18

19
int main(){
20
    printDoubled(1, 2.3, string("abcde")); //输出 2 4.6 abcdeabcde。注意字面值是`const char*`类型。
21
    //等于调用 print(1+1), print(2.3 + 2.3), print(string("abcde") + string("abcde"))
22
    return 0;
23
}

1
template<typename... T>
2
void printDoubled (T const&... args)
3
{
4
    print(1 + args...); //要么这么写
5
    print(args + 1 ...); //要么这么写。但是1和...必须分开。
6
    print((args + 1)...); //要么这么写。多加个括号。
7
}

1
template<typename T1, typename... TN>
2
constexpr bool isSameType (T1, TN...)
3
{
4
    return (std::is_same<T1,TN>::value && ...); // since C++17
5
}
6

7
int main(){
8
    cout << isSameType(1,2,3,4) << endl; //输出1 true
9
    //这一行会被扩展为 std::is_same<int,int>::value && std::is_same<int,int>::value && std::is_same<int,int>::value
10
    cout << isSameType(1,2,"123",4) << endl; //输出0 false
11
    //这一行会被扩展为 std::is_same<int,int>::value && std::is_same<int,const char*>::value && std::is_same<const char*,int>::value
12
    cout << isSameType("abc", "abcde") << endl; //输出1 true 特别注意这里
13
    return 0;
14
}

1
template<typename Container, typename Index>
2
void getItem(Container& container, Index idx){
3
    cout << container[idx] << endl;
4
}
5

6
int main(){
7
    //printDoubled(1, 2.3); //输出 2 4.6
8
    vector<string> my_vec{"abc", "def", "ghi", "123", "456"};
9
    getItem(my_vec, 3); //输出 123
10
    return 0;
11
}

1
template<typename T> //要有单参打印的重载。不然会无限调用。
2
void print(T t){
3
    cout << t << endl;
4
}
5

6

7
template<typename... Args>
8
void print(Args... args){
9
    (print(args), ...); //这里外部一定要加括号。注意语法。这里的,是逗号运算符。
10
}
11
//--------------------------上面是之前我们一直在用的print模板，这里也放一个方便查看---------------------
12
template<typename Container, typename... Index> //模板参数包
13
void getMultipleItem(Container& container, Index... idx){//函数参数包
14
    print(container[idx]...); //参数包
15
}
16
int main(){
17
    vector<string> my_vec{"abc", "def", "ghi", "123", "456"};
18
    getMultipleItem(my_vec, 1,2,3,4);
19
    //输出def ghi 123 456
20
    return 0;
21
}

1
T x = T();

1
template<typename T>
2
class MyClass {
3
    private:
4
        T x;
5
    public:
6
        MyClass() : x{} {} //确保当T为内置类型时，x值为0。注意第一个花括号为值初始化。第二个花括号是构造函数的函数体。
7
};

1
MyClass() : x() {}

1
template<typename T>
2
class MyClass {
3
  private:
4
    T x {}; // 使用值初始化，确保当T为内置类型时，x值为0。
5
};

1
template<typename T>
2
void foo(T p{}){
3
    //错误
4
}

1
template<typename T>
2
void foo(T p = T{}){
3
    //正确。但如果C++11之前的话必须把T{}换成T()
4
}

1
class getInt{
2
    public:
3
        float val;
4
        getInt(float a): val(a){};
5
        template<typename T = int> //成员函数模板。此处模拟一个返回int
6
        T get() const{
7
            return val;
8
        }
9
};
10

11
template<> //全特化，此处模拟返回string。这里有细节
12
inline string getInt::get<string>() const{ //注意这里的inline
13
    return to_string(val);
14
}
15

16
int main(){
17
    getInt myobj(12.345);
18
    auto t = myobj.get();
19
    cout << t << endl; //12
20
    auto t1 = myobj.get<string>(); //12.345000
21
    cout << t1 << endl;
22
    return 0;
23

24
}

1
template<class T>
2
 int f(T& x) {
3
     return x.template convert<3>(pi);
4
 }

1
return x.convert<3>(pi);

1
return ((x.convert) < 3) > (pi);

1
template<class T>
2
 void f(T& x, T& y) {
3
     int n = x.template convert<int>();
4
     int m = y->template convert<int>();
5
 }
6

7
 template<class T> struct other;
8
 template<class T>
9
 struct dirived : other <T>::template base<int> {};

1
template<typename T>
2
T my_val = 20.1234;
3
int main(){
4
    cout << my_val<int> << endl; //20
5
    cout << my_val<double> << endl; //20.1234
6
}

1
template<typename T = double> //默认参数
2
T my_val = 20.1234;
3
int main(){
4
    cout << my_val<int> << endl;  //20
5
    cout << my_val<> << endl; //20.1234
6
}

1
cout << my_val << endl; //错误

1
template<typename T>
2
class myobj{
3
    public:
4
        static const int val = 1000; //static 和 const一起修饰变量可以在类内赋初值
5
};

1
int out_val = myobj<int>::val;
2
int main(){
3
    cout << out_val << endl;
4
    return 0;
5
}

1
template <typename T>
2
int out_val_T = myobj<T>::val; //成员变量模板
3

4
int out_val1 = out_val_T<int>; //直接使用
5

6
int main(){
7
    cout << out_val1 << endl;
8
    return 0;
9
}

1
template <typename T1, typename T2>
2
struct S{
3

4
};
5
template <template <typename, typename> typename T1>
6
struct A{
7
    T1<int, double> obj; //可以在类内通过模板名T1这样实例化。
8
};
9

10
int main(){
11
    A<S> obj1; //模板模板参数期待的是一个模板名。
12
    A<S<int, double> obj2; //错误，不能这样指定，这是具体类型了。
13
}

1
template <typename T1, typename T2>
2
struct S{
3

4
};
5
template <typename T, template <typename, typename> typename T1 = S>
6
struct A{ //这里模板模板参数的默认值必须是一个模板名，不可以是S<T,int>这样的具体类型名
7
    T1<T, double> obj; //可以在类内通过模板名T1这样实例化。
8
};
9

10
int main(){
11
    A<int, S> obj1; //模板模板参数期待的是一个模板名。
12
}

1
template <typename T1, typename T2>
2
struct S{
3
};
4
template <typename T, typename T1 = S<T, double>>
5
struct A{ //非模板模板参数的写法
6
    T1 obj;
7
};
8

9
int main(){
10
    A<int> obj1;
11
}

1
template <typename T, template <typename Elem, typename = std::allocator<Elem>> typename Container = std::vector>
2
class Stack {
3
    public:
4
        Container<T> elems; // container<T>会默认调用对应的容器的默认分配器
5
};
6
int main(){
7

8
    Stack<int, deque> sss; //一个stack，实现基于deque类，储存int类型数据
9
    Stack<int> ssss; //一个stack，使用默认值实现基于vector类，储存int类型数据
10

11
}

1
template <typename T, template <typename> typename Container = std::vector>

1
Stack<int, array> sss;

1
template <typename T>
2
using deq = deque<T>; //要不然用别名模板也算是显式指定容器元素类型和分配器。
3
template <typename T>
4
using arr = array<T, 10>; //注意array的第二个参数必须给。因为没有默认值。
5
template <typename T, template <typename> typename Container>
6
class Stack {
7
    public:
8
        Container<T> elems; // container<T>会默认调用对应的容器的默认分配器
9
};
10
int main(){
11

12
    Stack<int, deq> sss; //一个stack，实现基于deque类，储存int类型数据
13
  Stack<int, arr> ssss; //一个stack，实现基于array类，储存int类型数据
14
}

1
template <typename T, template <typename ...> class Container>   //使用可变参数模板简化后的方式 注意array不可以 array的第二个参数是非类型模板参数
2
class Stack {
3
    public:
4
        Container<T> elems; // container<T>会默认调用对应的容器的默认分配器
5
};
6
int main(){
7

8
    Stack<int,deque> ss; //一个stack，实现基于deque类，储存int类型数据
9

10
}

1
                                       ↓container类的默认参数的类型。因为没用到可以忽略  ↓ container类的默认参数。可以不写
2
template <typename T, template <typename U, typename Alloc = allocator<U>> class Container = deque>
3
           ↑这个T意思是储存T类型数据                    ↑这个Alloc是contain类的默认方法的U类型的分配器。因为没用到可以忽略
4
//上面这样做会让stack模板强制要求容器模板支持第二个参数
5
template <typename T, template <typename ...> class Container>   //使用可变参数模板简化后的方式
6
template <typename T, template <typename, typename> class Container> //不能这么写，下面container<T>会少一个参数，但是你上面必须写俩必须写分配.

1
template <typename T1, typename T2>
2
struct S{
3
    void func(){
4
        std::puts(__PRETTY_FUNCTION__);
5
        cout <<"called" << endl;
6
    }
7
};
8
template <typename T, typename T1, template<typename, typename > typename T2>  //T2是模板模板参数，接受一个模板名
9
struct A: T2<T, T1>{//继承自T2类，T和T1是实例化T2所必需的模板参数
10
};
11

12
int main(){
13
    A<int, double, S> obj;
14
    obj.func();
15
}