C++基础学习-34可变参模板，模板模板参数

一、可变参函数模板

可变参模板：（Variadic Templates)：允许模板中含有0个到任意个模板参数，在语法上也和传统模板不太一样，多了一个…

1.1 简单范例

template <typename... T>
void funct1(T... args) //T：一包类型   ，args：一包形参
{
	cout << sizeof...(args) << endl;   //sizeof...可变参数量
	cout << sizeof...(T) << endl;
}
int main()
{
	funct1();
	funct1(20, 20);
	funct1(30, 21321.1, "abcdefgd");
	return 0;
}

1. 我们一般把这个args称为一包或者一堆参数，而且这些参数的类型可以各不相同；我们理解T这种类型的时候，不能把他理解成一个类型，你要理解成0到多个不同的类型，那自然，对应的参数args也应该是多个不同类型的参数；
2. 这一包参数中可以容纳0到多个模板参数，而且这些模板参数可以为任意的类型；
3. T后边带了…，所以，我们称呼T为可变参类型；看起来是一个类型名，实际上里边包含的是0到多个不同的类型（一包类型）；args：可变形参，既然T代表的是一包类型，那显然args代表的就一包形参。
4. 在具体函数形参中，&的位置，出现在了类型名的后边。

template <typename T, typename...U>
void myfunct2(const T& firstarg, const U&... otherargs)  //一个参数，一包参数，这种可变参函数模板写法最适合参数包的展开
{
}

1.2 参数包的展开

//递归终止 函数
void myfunct2()
{
	cout << "参数包展开时执行了递归终止函数myfunc2()..." << endl;
}
template <typename T, typename...U>
void myfunct2(const T& firstarg, const U&... otherargs)  //一个参数，一包参数，这种可变参函数模板写法最适合参数包的展开
{
	//cout << sizeof...(otherargs) << endl;
	cout << "收到的参数值为:" << firstarg << endl;
	myfunct2(otherargs...); //递归调用，注意写法...
}
int main()
{
	myfunct2(10);
	myfunct2(10, "abc", 12.7);
	myfunct2("abc", 12.7);
	myfunct2(12.7);
	myfunct2();
	return 0;
}

二、可变参类模板

允许模板定义中含有0到任意个模板参数。

2.1 通过递归继承方式展开参数包

namespace _nmsp1
{  
    template<typename...Args> class myclass {};//主模版
    template<> class myclass<> //0个模板参数的特化版本
    {
        public:
            myclass()
            {
                printf("myclass<>::myclass() %p\n",this);
            } 
    };
    template <typename First,typename... Others> //偏特化 通过继承
    class myclass<First,Others...> :private myclass<Others...>
    {
       public:
            myclass():m_i(0)
            {
                printf("myclass<>::myclass%p\n",this);
            }
            myclass(First pf,Others...po):m_i(pf),myclass<Others...>(po...)
            {
                cout << "--------------------begin-------------------" << endl;
                printf("myclass<>::myclass(First pf,Others...po):m_i(pf) %p\n",this);
                cout << "m_i = " << m_i << endl;
                cout << "--------------------end-------------------" << endl;
            }
            First m_i;
            myclass<Others...> m_o;//组合方式
    };
    void func()
    {
        myclass<int,float,double> myc(1,0.2f,3);
    }
}

2.2 通过递归组合方式展开参数包

namespace _nmsp1
{  
    template<typename...Args> class myclass {};//主模版
    template<> class myclass<> //0个模板参数的特化版本
    {
        public:
            myclass()
            {
                printf("myclass<>::myclass() %p\n",this);
            }
               
    };
    template <typename First,typename... Others> //偏特化
    class myclass<First,Others...>//:private myclass
    {
       public:
            myclass():m_i(0)
            {
                printf("myclass<>::myclass%p\n",this);
            }
            myclass(First pf,Others...po):m_i(pf),m_o(po...)
            {
                cout << "--------------------begin-------------------" << endl;
                printf("myclass<>::myclass(First pf,Others...po):m_i(pf) %p\n",this);
                cout << "m_i = " << m_i << endl;
                cout << "--------------------end-------------------" << endl;
            }
            First m_i;
            myclass<Others...> m_o;//组合方式
    };
    void func()
    {
        myclass<int,float,double> myc(1,0.2f,3);
    }
}

2.3 通过tuple和递归调用展开参数包

template<int mycount, int mymaxcount, typename... T>
class myclass1
{
public:
	static void mysfunc(const tuple<T...>& t)
	{
		cout << "value = " << get<mycount>(t) << endl;
		myclass1<mycount + 1, mymaxcount, T...>::mysfunc(t);
	};
};

//还需要一个特化版本 用于结束递归调用
template<int mymaxcount, typename... T>
class myclass1<mymaxcount, mymaxcount, T...>
{
public:
	static void mysfunc(const tuple<T...>& t)
	{
	};
};

template<typename... T>
void mysfunc(const tuple<T...>& t)
{
	myclass1<0, sizeof...(T), T...>::mysfunc(t);
}

int main()
{
	tuple<float, int, int> mytuple(12.5f, 100, 52);
	mysfunc(mytuple);
	return 0;
}

二、模板模板参数

namespace _nmsp3
{
    //模板 模板参数
    template<
        typename T, // 类型模板参数　
        // template class Container//模板模板参数
        template<typename W> typename Container //模板模板参数
            >
    class myclass3
    {
        public:
            T m_i;
            Container<T> myc;
            myclass3()
            {
                for(int i=0;i<10;i++)
                {
                    myc.push_back(i);
                }
            }
    };
    // template using myvector = vector >;
    // template using myList = list>;

    void func()
    {
        // myclass3 myc3;
    }
}