第四章 可变参数模板

最新推荐文章于 2024-05-08 22:01:18 发布
最新推荐文章于 2024-05-08 22:01:18 发布
阅读量456 收藏 5
点赞数 7
分类专栏： C++ 模板 文章标签： 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jj147258369/article/details/136921053
版权

简单示例

C++11 新特性，可以使用可变数量的模板参数

#include <iostream>

void print() {} // 递归基, 也就是递归的尽头

// 递归函数, T 是参数类型, ... 是参数列表
template<typename T, typename... Args>
void print(T first_arg, Args... args) {
    std::cout << first_arg << " \n"; // 打印第一个参数
    print(args...); // 递归调用，传入剩下的参数列表
}

int main() {
    print(1, 2.2, "hello");
}

或者，重载一个单模板参数的模板函数:

#include <iostream>

template<typename T> 
void print(T arg) {
    std::cout<<arg<<std::endl;
}

// 递归函数, T 是参数类型, ... 是参数列表
template<typename T, typename... Args>
void print(T first_arg, Args... args) {
    print(first_arg); // 调用单参数版本的print
    print(args...); // 将模板参数列表传递给print
}

int main() {
    print(1, 2.2, "hello");
}

C++11 还为可变参模板引入了一种新的操作符:sizeof…，其值为参数包包含的元素数量:


#include <iostream>

template<typename T> 
void print(T arg) {
    std::cout<<arg<<std::endl;
}

// 递归函数, T 是参数类型, ... 是参数列表
template<typename T, typename... Args>
void print(T first_arg, Args... args) {
    std::cout<<"现在参数列表还有"<<sizeof...(args)<<"个参数\n";
    print(first_arg); // 调用单参数版本的print
    print(args...); // 将模板参数列表传递给print
}

int main() {
    print(1, 2.2, "hello");
}

折叠表达式

C++17新特性， 可以对参数包（列表）中的所有参数使用二元运算符计算结果，前提是参数包不为空（除非是空参数包进行 && 或者 || 操作）：

#include <iostream>

template<typename... Args> 
auto Sum(Args... args) {
    return (args + ...); // 等价于 (... + args)
}

int main() {
    std::cout<<Sum(1, 2.2, 3.1)<<std::endl; // 计算综合
    std::cout<<Sum()<<std::endl; // 错误，Unary fold expression has empty expansion for operator '+' with no fallback value
}

#include <iostream>

template<typename... Args> 
auto Sum(Args... args) {
    return (args + ... + 3); // 带init的折叠表达式，从3开始加
}

int main() {
    std::cout<<Sum(1, 2.2, 3.3)<<std::endl; // 结果为 false
}

#include <iostream>

template<typename... Args> 
auto Sum(Args... args) {
    return (args && ...); 
}

int main() {
    std::cout<<Sum()<<std::endl; // 结果为 true
}

#include <iostream>

template<typename... Args> 
auto Sum(Args... args) {
    return (... || args);
}

int main() {
    std::cout<<Sum()<<std::endl; // 结果为 false
}

还可以打印参数包中的所有参数：

#include <iostream>

// 封装一下，保证每个函数的参数后面都加一个空格
template<typename T> 
class AddSpace
{
private:
    T const& ref; // refer to argument passed in constructor public:
public: 
    explicit AddSpace(T const& r): ref(r) {}
    friend std::ostream& operator<< (std::ostream& os, AddSpace<T> s) {
        return os << s.ref << ' '; // output passed argument and a space 
    }
};


template<typename... Args>
void Print(const Args&... args) {
    (std::cout << ... << AddSpace(args) ) << std::endl;
}

int main() {
    Print(1, 2.2, "name");
}

可变参数函数模板参数与普通参数适用相同的规则。通过值传递，参数复制并衰变 (例如，数 组变成指针)，若通过引用传递，参数指向原始参数，而不衰变

应用

  1. 比如，我想将所有参数包（类型可能不一致）都各自相加一次，然后输出：
#include <iostream>

// 封装一下，保证每个函数的参数后面都加一个空格
template<typename T> 
class AddSpace
{
private:
    T const& ref; // refer to argument passed in constructor public:
public: 
    explicit AddSpace(T const& r): ref(r) {}
    friend std::ostream& operator<< (std::ostream& os, AddSpace<T> s) {
        return os << s.ref << '\n'; // output passed argument and a space 
    }
};


template<typename... Args>
void Print(const Args&... args) {
    (std::cout << ... << AddSpace(args) ) << std::endl;
}

// 每个参数都自己和自己相加，然后输出
template<typename... Args>
void DoublePrint(const Args&... args) {
    Print(args + args...); // 相当于 Print(1+1, 2.2 + 2.2, "name" + "name");
}

int main() {
    // 2  4.4  namename 
    DoublePrint(1, 2.2, std::string("name"));
}
  1. 给参数包的每个元素都 加上一个值：
#include <iostream>

// 封装一下，保证每个函数的参数后面都加一个空格
template<typename T> 
class AddSpace
{
private:
    T const& ref; // refer to argument passed in constructor public:
public: 
    explicit AddSpace(T const& r): ref(r) {}
    friend std::ostream& operator<< (std::ostream& os, AddSpace<T> s) {
        return os << s.ref << '\n'; // output passed argument and a space 
    }
};


template<typename... Args>
void Print(const Args&... args) {
    (std::cout << ... << AddSpace(args) ) << std::endl;
}

// 每个参数都自己和自己相加，然后输出
template<typename... Args>
void AddOnePrint(const Args&... args) {
    Print(args + 1 ...); // 正确， 1 和 ... 要空一行
    // Print(args + 1...); // 语法错误
    // Print((args + 1)...); // 正确
}

int main() {
    // 2  4.4  namename 
    AddOnePrint(1, 2.2, 3);
}

ps: 不得不说，这里的语法很抽象。。。

  1. 判断参数包中的所有元素是否全都是同一个参数类型（C++17 only）：
#include <iostream>
template<typename T1, typename... TN> 
constexpr bool isHomogeneous (T1, TN...) {
    return (std::is_same_v<T1,TN> && ...); // 只要参数包内所有类型相同，返回true
}

int main() {
    // 2  4.4  namename 
    std::cout << isHomogeneous(2,4.4,"namename") << std::endl;
    std::cout << isHomogeneous(1,2,3,4,5) << std::endl;
}
  1. 参数包当作索引，访问数组元素:

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

// 封装一下，保证每个函数的参数后面都加一个空格
template<typename T> 
class AddSpace
{
private:
    T const& ref; // refer to argument passed in constructor public:
public: 
    explicit AddSpace(T const& r): ref(r) {}
    friend std::ostream& operator<< (std::ostream& os, AddSpace<T> s) {
        return os << s.ref << '\n'; // output passed argument and a space 
    }
};


template<typename... Args>
void Print(const Args&... args) {
    (std::cout << ... << AddSpace(args) ) << std::endl;
}

// 每个参数都自己和自己相加，然后输出
template<typename T, typename... Index>
void printElems(const T& coll, Index... idx) {
    Print(coll[idx]...);
}

int main() {
    std::vector<std::string> arr{"accd", "efg", "hijk", "lmn"};
    printElems(arr, 0, 2, 3);
    printElems(arr, 1.9, 2.1, 3.5); // 如果不是整型，会直接取整成[1,2,3] 
}

当然，还有另外一种写法，直接使用非类型的参数模板：


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

// 封装一下，保证每个函数的参数后面都加一个空格
template<typename T> 
class AddSpace
{
private:
    T const& ref; // refer to argument passed in constructor public:
public: 
    explicit AddSpace(T const& r): ref(r) {}
    friend std::ostream& operator<< (std::ostream& os, AddSpace<T> s) {
        return os << s.ref << '\n'; // output passed argument and a space 
    }
};


template<typename... Args>
void Print(const Args&... args) {
    (std::cout << ... << AddSpace(args) ) << std::endl;
}

template<std::size_t... Index, typename T>
void printElems(const T& coll) {
    Print(coll[Index]...);
}

int main() {
    std::vector<std::string> arr{"accd", "efg", "hijk", "lmn"};
    printElems<0,2,3>(arr);
}
  1. 类模板做索引
#include <iostream>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
#include <algorithm>

// 封装一下，保证每个函数的参数后面都加一个空格
template<typename T> 
class AddSpace
{
private:
    T const& ref; // refer to argument passed in constructor public:
public: 
    explicit AddSpace(T const& r): ref(r) {}
    friend std::ostream& operator<< (std::ostream& os, AddSpace<T> s) {
        return os << s.ref << '\n'; // output passed argument and a space 
    }
};


template<typename... Args>
void Print(const Args&... args) {
    (std::cout << ... << AddSpace(args) ) << std::endl;
}


template<std::size_t...>
struct Indices{
};

template<typename T, std::size_t... Index>
void printByIndex(T t, Indices<Index...> /*unused*/) {
    Print(std::get<Index>(t)...);
    // Print(t[Index]...); // 同上
}

int main() {
    std::array<std::string, 4> arr{"accd", "efg", "hijk", "lmn"}; 
    printByIndex(arr, Indices<0, 2, 3>());
}

总结

• 通过使用参数包，可以为任意数量、类型的模板参数定义模板。 • 要处理参数，需要递归和/或匹配的非变参函数。
• 操作符 sizeof… 可为参数包提供的参数数量。
• 可变参数模板的一个应用是转发任意数量的类型参数。
• 通过使用折叠表达式，可以对参数包中的所有参数使用相应的操作符。

YAFree123
关注
  • 7
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
-C++参考大全(第四版) (2010 年度畅销榜
12-08
第4章 数组和以null结束的字符串 4.1 一维数组 4.2 生成指向数组的指针 4.3 向函数传递一维数组 4.4 以null结束的字符串 4.5 二维数组 4.6 多维数组 4.7 带下标的指针 4.8 数组初始化 4.9 棋盘游戏实例 第5章 指针 ...
【 C++11 】可变参数模板
bit_zyx的博客
10-15 3247
目录 1、可变参数模板的概念 2、参数包的展开方式 递归函数方式展开参数包 逗号表达式展开参数包 3、STL容器中的empalce相关接口函数
【C++】C++11可变参数模板（函数模板、类模板）
热门推荐
Yngz_Miao的博客
04-01 3万+
在C++11之前，类模板和函数模板只能含有固定数量的模板参数。C++11增强了模板功能，允许模板定义中包含0到任意个模板参数，这就是可变参数模板。可变参数模板的加入使得C++11的功能变得更加强大，而由此也带来了许多神奇的用法。 本文实例源码github地址：https://github.com/yngzMiao/yngzmiao-blogs/tree/master/2020Q2/20200401...
可变参数模板 Variadic Templates
Dong_HFUT的博客
06-26 2323
从 C++11 开始，模板可以有任意个模板参数，也即所谓的可变参数模板。定义一个函数 如下，用于接收不同类型的不同参数。 被称为模板参数包（template parameter pack）， 被称为函数参数包（function parameter pack）。模板函数 首先打印第一个参数，然后递归调用自己打印剩余参数。为了结束递归，需要提供一个非模板类型重载函数，用于处理最后的空参数包。为了更直观地感受可变参数模板地递归处理过程，可以在以上 中插入 ，打印出函数的调用。 当发生 调用时，输出如下：
＜C++＞ 可变参数模板
ikun66666的博客
06-21 904
C++可变参数模板，emplace接口
C++11(四)可变参数模板
想要上进的coder的博客
10-05 1176
由于是逗号表达式，在创建数组的过程中会先执行逗号表达式前面的部分printarg(args)打印出参数，也就是说在构造int数组的过程中就将参数包展开了，这个数组的目的纯粹是为了在数组构造的过程展开参数包。我们无法直接获取参数包args中的每个参数的，只能通过展开参数包的方式来获取参数包中的每个参数，这是使用可变模版参数的一个主要特点，也是最大的难点，即如何展开可变模版参数。的函数模板和类模板，相比C++98/03，类模版和函数模版中只能含固定数量的模版参数，可变模版参数无疑是一个巨大的改进。
可变参数模板
qq_36553387的博客
08-09 324
文章目录可变参数模板sizeof...运算符编写可变参数函数模板包扩展理解包扩展转发参数包 可变参数模板 一个可变参数模板就是一个接收可变数目参数的模板函数或模板类。可变数目的参数被称为参数包。存在两种参数包：模板参数包，表示零个或多个模板参数；函数参数包，表示零个或多个函数参数。 使用一个省略号来指出一个模板参数或函数参数表示一个包。在一个模板参数列表中，class...或typename...指出接下来的参数表示零个或多个类型的列表；一个类型名后面跟一个省略号表示零个或多个给定类型的非类型参数的列表。在
C++11 ——— 可变参数模板
裙下的霸气的博客
02-28 900
C++11 可变参数模板
C++可变参数模板
天道酬勤
06-11 6999
可变参数模板是一个接受可变数目参数的模板函数或模板类，在模板参数列表中，typename…指出接下来的参数表示0个或多个类型的列表，一个类型名后面跟省略号表示0个或多个给定类型的非类型参数的列表。在函数参数列表中，如果一个参数的类型是一个模板参数包，则此参数也是一个函数参数包。 可变参数模板通常是递归的，第一步调用处理包中的第一个实参，然后用剩余实参调用自身， sizeof…运算符可以获得包中元素...
C++ 可变参数模板
无人之国
01-07 1351
可变参数模板可变参数模板参数包示例1示例2参考资料 可变参数模板 一个可变参数模板(variadic template)就是一个接受可变数目参数的函数模板或类模板。 参数包 可变数目的参数被称为参数包(parameter packet)。 存在两种参数包：模板参数包(template parameter packet)，表示0个或多个模板参数；函数参数包(function parameter packet)，表示0个或多个函数参数。 采用省略号(…)的形式来指出这是一个参数包。 在模板参数列表中，class
【C++杂货铺】C++11新特性——可变参数模板
春人.的博客
01-02 6339
本篇文章介绍了 C++11 中新引入的可变模板参数，以及基于可变模板参数的 emplace 系列接口的使用原理。
PHP和MySQL WEB开发(第4版)
05-31
第4章 字符串操作与正则表达式 4.1 创建一个示例应用程序：智能表单邮件 4.2 字符串的格式化 4.2.1 字符串的整理：chop()、ltrim()和trim() 4.2.2 格式化字符串以便显示 4.2.3 格式化字符串以便存储：addslashes()和...
Visual.Basic.2010.&.NET4.高级编程(第6版)-文字版.pdf
03-20
第4章 公共语言运行库 213 4.1 .net应用程序的组成元素 214 4.1.1 模块 214 4.1.2 程序集 215 4.1.3 类型 215 4.2 版本化与部署 216 4.2.1 对版本化更好的支持 216 4.2.2 major.minor.build.revision...
C++ Primer第四版【中文高清扫描版】.pdf
03-13
第4章　数组和指针 95 4.1 数组 96 4.1.1 数组的定义和初始化 96 4.1.2 数组操作 99 4.2 指针的引入 100 4.2.1 什么是指针 100 4.2.2 指针的定义和初始化 101 4.2.3 指针操作 104 4.2.4 使用指针访问数组元素 106 ...
LeetCode算法题：9. 回文数（Java解法）
tqh267的博客
05-08 393
只是在防止反转后数值溢出处理使用了判断逻辑，判断int型溢出逻辑可以查看我的第8题讲解文章，即在计算之前判断是否大于int的最大值/10，以及再计算之后的值是否小于0。将整数转为字符串->分别定义一个下标指向字符串头和尾，以此对比头和尾所指字符是否相同，如果不同则返回false，直到头下标超过尾下标，表示是回文数，返回true。将整数转为字符串->将字符串反转->判断反转后的字符串是否与之前字符串相同，如果相同则是回文数，否则不是回文数。是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
算法训练Day26 | 332.重新安排行程 ● 51. N皇后 ● 37. 解数独
最新发布
WIIIter的博客
05-08 135
【代码】算法训练Day26 | 332.重新安排行程 ● 51. N皇后 ● 37. 解数独。
浅谈TopK问题（堆的应用，文件处理，堆排序）
lzh20040919的博客
04-30 465
这些排序方法就不适用了，就比如当数据到达10亿时，再使用冒泡排序，它的时间复杂度就相当恐怖了，这时我们就要用到。，如果我们按上述操作对堆顶元素进行替换，那么也只能不断更新这个最大值，我们能使用的方法有很多，就比如比较简单的冒泡排序，他的时间复杂度是。的性质来满足我们的TopK了，这时它的时间复杂度是。在文件data.txt中找出前K个最大的数据。，循环完成后小堆就剩下前K个最大的数据。堆实现思路：（前K个最大的数据）找出最大或最小的前K个数据。找最大建小堆，找最小建大堆。个数据建大小为K的小堆。
c++容器与算法概述
北风
05-01 596
简单讲述输入输出运算符重载 以及容器的简单使用及接口哦苦
C++中可变参数与非可变参数
06-01
可变参数在 C++ 中通常使用可变参数模板实现，即模板参数数量不确定，参数类型也不确定，需要在函数调用时确定具体类型和数量。C++11 引入了 `std::initializer_list`，可以方便地实现可变参数模板。 例如，下面是...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值