C++模板——学习笔记4

4.1变参模板

4.1.1 实例（一步到位版）

#include<iostream>
#include<string>
#include<vector>

using namespace std;
template<typename T1,typename... T2>
void myprint(T1 arg1,T2... arg2)
{
    cout<<arg1<<endl;

    if constexpr(sizeof...(arg2)>0)
    {
        myprint(arg2...);
    }
}

int main()
{
    myprint(1,"232","aaa");
}

这里用到了三个新概念：

1. …
   用于定于可变参数包，有三处在使用，第一个是typename… T2用于定义模板参数包，第二个是T2… arg2用于定义函数参数包，第三个是在实际使用参数时定义arg2…，代表剩余参数。
2. sizeof…运算符
   用于计算参数包 中剩余参数个数
3. constexpr
   定义为常量表达式，因为之前提到过，模板的是实例化是在编译期间就决定的，如果sizeof…(arg2）前不加constexpr,则是在运行期间计算参数包个数，无法通过编译。

如果使用其他方式，则需要在编写完函数模板后，编译一个递归终止print空函数，如下图

4.2 折叠表达式

示例：

template <typename... T>
auto sub_val_left(T... args)
{
   return (... - args); //一元左折
}
template <typename... T>
auto sub_val_right(T... args)
{
   return (args - ...); //一元右折
}

template <typename... T>
auto sub_val_left_b(T... args)
{
   return (220 - ... - args); //二元左折：220就是init
}
template <typename... T>
auto sub_val_right_b(T... args)
{
   return (args - ... - 220); //二元左折：220就是init
}
int main()
{
   cout << sub_val_left(10, 20, 30,40) << endl;  //-80：((10-20)-30)-40
   cout << sub_val_right(10, 20, 30, 40) << endl; //-20：10-(20-(30-40))
   cout << sub_val_left_b(10, 20, 30, 40) << endl; //120：(((220-10)-20)-30)-40
   cout << sub_val_right_b(10, 20, 30, 40) << endl; //200：10-(20-(30-(40-220)))

}

示例：

 template<typename... Args>
void myprintA (Args... args)
{
    (std::cout << ...<<args) << endl;
}
int main()
{
    ::myprintA(1,2,3,"3243");
}

也可实现批量打印，但无空格，并且需要注意加括号(std::cout << …<<args)，否则编译不过

4.3 变参模板的使用

变参模板在泛型库的开发中有重要的作用，比如 C++标准库。
一个重要的作用是转发任意类型和数量的参数。比如在如下情况下会使用这一特性：

简单来说就是参数个数不固定的接口

4.4 变参类模板和变参表达式

示例——参数值翻倍：

template<typename... T>
void myprintDouble(T const&... args)
{
    myprint(args+args...);
}

int main()
{
    ::myprintDouble(1,2,3,string("123"));//2 4 6 123123
}

示例——判断入参是否类型一致

template<typename T1,typename... T2>
bool isSameType(T1 arg1,T2... arg2)
{
    return (std::is_same<T1,T2>::value && ...);
}
int main()
{
    cout<<isSameType(43,-1)<<endl;//1
    cout<<isSameType(43,-1,"223")<<endl;//0
}

示例——变参下标（打印一个数组下多个元素）

template<typename T1,typename... I>
void printElem(T1 const& arr,I... idx)
{
    myprint(arr[idx]...);
}
int main()
{

    vector<int> arrayTest = {1,3,5,6,7};
    printElem(arrayTest,0,1,4);//1 3 7
}

也可将非类型模板参数声明为参数包，eg:

template<std::size_t... Idx,typename T1>
void printElemA(T1 const& arr)
{
    myprint(arr[Idx]...);
}
int main()
{
    vector<int> arrayTest = {1,3,5,6,7};
    printElemA<0,1,4>(arrayTest);//1 3 7
}

变参推断指引

template<typename T>
struct Check1
{
    //如果T的类型是int，则定义函数 int read(void* = nullptr)
	template<typename U = T>
	U read(typename std::enable_if_t<std::is_same_v<U, int> >* = nullptr) {
		return 42;
	}

    //如果T的类型是double，则定义函数 double read()
	template<typename U = T>
	typename std::enable_if_t<std::is_same_v<U, double>, U> read() {
		return 3.14;
	}
};
std::enable_if_t<std::is_same_v<double, double>,double> func(){
    return 3.33;
};

int main()
{


    cout<<Check1<int>().read()<<endl;
    cout<<Check1<double>().read()<<endl;
    cout<<func()<<endl;
}

以typename std::enable_if_t<std::is_same_v<U, double>, U> read()为例子进行解释，enable_if_t是一个函数模板，当第一个入参为true时，将double作为read（）的返回值类型，第，一个入参为false时,产生编译报错
error: no matching function for call to ‘Check1::read()’|，关于详细的使用，可参考该博客https://blog.csdn.net/baidu_41388533/article/details/109690122,
is_same_v等价于std::is_same::value,用于比较两个数据类型是否一致
enable_if_t等价于typename std::enable_if<表达式>::type