003 可变参数模板

可变参数模板

一、可变参数模板

template <typename T, typename ... Args> 
void fun(T t, Args ... args);//合法 

template <typename ... Args, typename T> 
void fun(Args ... args, T t);//非法

// Args是一个模板参数包; rest是一个函数参数包
// Args表示零个或多个模板类型参数
// rest表示林个或多个函数参数
template <typename T, typename ... Args>
void foo(const T &t, const Args& ... rest)

int i = 0； double  d = 3.14; strng s = "how now brown cow";
foo(i, s, 42, d);
foo(s, 42, "hi");
foo(d, 42);
foo("hi");

void foo(const int&, const string&, const int&, const double&);
void(const string&, const int&, const char[3]&);
void foo(const double&, const string&);
void foo(const char[3]&);

二、sizeof...运算符

【注意】当我们需要知道包中有多少个元素时，可以用sizeof...

#include<iostream>
#include<string>
using namespace std;

template <typename T, typename ... Args>
void foo(const T&, const Args& ... rest)
{
    cout << sizeof...(Args) << " ";  //模板类型参数的数目
    cout << sizeof...(rest) << endl; // 函数参数的数目
}

int main()
{
    int i = 0; double  d = 3.14; string s = "how now brown cow";
    foo(i, s, 42, d);
    foo(s, 42, "hi");
    foo(d, 42);
    foo("hi");

    return 0;
}

运行结果：

三、编译可变参数函数模板

非可变参数模板比可变参数模板更特例化，因此编译器选择非可变参数版本。

#include<iostream>
#include<string>
using namespace std;

template <typename T>
ostream& print(ostream &os, const T &t)
{
    return os << t << endl;
}

template <typename T, typename ... Args>
ostream &print(ostream &os, const T &t, const Args& ... rest)
{
    os << t << " , ";
    return print(os, rest ...);
}

int main()
{
    int i = 0;
    string s = "hello";
    
    print(cout, i);
    print(cout, i, s);
    print(cout, i, s, 42.1, 'A', "End");
    return 0;
}

运行结果：

练习16.55

 

四、包扩展

#include <iostream>
using namespace std;

template <typename T>
T accum(const T &t)
{
    return t;
}

template <typename T, typename... Args>
T accum(const T &t, Args... args)
{
    return t + accum(args...);
}

int h()
{
    return 42;
}

template <typename ...Args>
int h(int t, Args ... args)
{
    return t + h(args...);
}

void f(int i, int j = 0, int k = 0, int l = 0)
{
    cout << i << " + "
        << j << " + "
        << k << " + "
        << l << " =  "
        << i + j + k + l << endl;
}

template<typename ... Args>
void g(Args ... args)
{
    cout << sizeof...(Args) << endl;
    cout << sizeof...(args) << endl;
    // h(a1, a2, a3, ..., an)
    f(args...);  
    // h(a1, a2, a3, ..., an)
    cout << h(args...) << endl; 
    //f(h(a1), h(a2), h(a3), ..., h(an))
    f(h(args) ...);  
    // f(h(a1, a2, a3, ..., an2)
    f(h(args ...));  
    // f(h(5,6,7,8) + a1, h(5,6,7,8) + a2, h(5,6,7,8) + a3, ..., h(5,6,7,8) + an)  
    f(h(5, 6, 7, 8) + args ...);                             
}

int main()
{
    cout << accum(1, 2, 3, 4) << endl;
    g(1, 2, 3, 4);
    return 0;
}

运行结果：

五、转发参数包

 模板特例化

1. 全特化就是全部特化，即针对所有的模板参数进行特化。

2. 偏特化就是部分特化，即针对部分模板参数进行特化。

全特化和偏特化的定义不是很严格，所以有的时候不容易让人理解。

#include <iostream>
using namespace std;

namespace templateTest {

    //模版泛化
    template<typename T>
    class iterator_traits
    {
    public:
        iterator_traits()
        {
            cout << "模版泛化" << endl;
        }

        ~iterator_traits()
        {

        }
    };

    //偏特化
    template<typename T>
    class iterator_traits<T*>
    {
    public:
        iterator_traits()
        {
            cout << "模版偏特化，特化常规指针" << endl;
        }

        ~iterator_traits()
        {

        }
    };

    //偏特化
    template<typename T>
    class iterator_traits<const T*>
    {
    public:
        iterator_traits()
        {
            cout << "模版偏特化，特化const指针" << endl;
        }

        ~iterator_traits()
        {

        }
    };

    //全特化
    template<>
    class iterator_traits<int>
    {
    public:
        iterator_traits()
        {
            cout << "模版全特化int类型" << endl;
        }

        ~iterator_traits()
        {

        }
    };
};

//泛化
template<class U, class T>
class Test
{
public:
    Test()
    {
        cout << "Test 泛化" << endl;
    }
};

//偏特化
template< class T>
class Test<int, T>
{
public:

    Test()
    {
        cout << "Test 偏特化" << endl;
    }
};

//全特化
template<>
class Test<int, char>
{
public:

    Test()
    {
        cout << "Test 全特化" << endl;
    }
};
template<typename T>
void max(const T& t1, const T & t2)
{
    cout << "模版函数泛化" << endl;

}

//其实函数模版不存在偏特化,只有全特化
template<>
void max<int>(const int& t1, const int& t2)
{
    cout << "模版函数特化" << endl;
}

void main()
{
    templateTest::iterator_traits<int> t1;
    templateTest::iterator_traits<float> t2;
    templateTest::iterator_traits<int *> t3;
    templateTest::iterator_traits<const int *> t4;
    Test<int, int> t5;
    Test<float, int> t6;
    Test<int, char> t7;
    max(5, 10);
    max(5.5, 10.5);
    system("pause");
}

运行结果：