【C++】C++11新特性——可变参数模板|function|bind

文章目录

  • 一、可变参数模板
    • 1.1 可变参数的函数模板
    • 1.2 递归函数方式展开参数包
    • 1.3 逗号表达式展开参数包
    • 1.4 empalce相关接口函数
  • 二、包装器function
    • 2.1 function用法
    • 2.2 例题：逆波兰表达式求值
    • 2.3 验证
  • 三、绑定函数bind
    • 3.1 调整参数顺序
    • 3.2 固定绑定参数

一、可变参数模板

在C语言中其实也有可变参数：
在这里插入图片描述

1.1 可变参数的函数模板

C++库里面也有很多使用可变参数函数模板的：
在这里插入图片描述

template <class ...Args>
void fun(Args... args)
{}

Args是一个模板参数包，args是一个函数形参参数包
声明一个参数包Args…args，这个参数包中可以包含0到任意个模板参数

以前只能传递一个对象做参数，有了可变参数包就可以传递0~n个参数：

template <class ...Args>
void fun(Args... args)
{
	// 获取参数包中有几个参数
	cout << sizeof...(args) << endl;
}

int main()
{
	fun();
	fun(1);
	fun(1, 1.1);
	fun(1, 1.1, std::string("abc"));
	std::vector<int> v;
	fun(1, 1.1, std::string("abc"), v);
	return 0;
}

在这里插入图片描述
那么怎么把这些参数取出来呢？

1.2 递归函数方式展开参数包

void fun()
{
	cout << endl;
}

template <class T, class ...Args>
void fun(T val, Args... args)
{
	cout << val << " ";
	fun(args...);
}

int main()
{
	fun();
	fun(1);
	fun(1, 1.1);
	fun(1, 1.1, std::string("abc"));
	return 0;
}

在这里插入图片描述
解释：

在这里插入图片描述
按照箭头的方式调用，最后当没有参数的时候就会走最上面的函数

1.3 逗号表达式展开参数包

template <class T>
void printArg(T val)
{
	cout << val << " ";
}

template <class ...Args>
void fun(Args... args)
{
	int arr[] = { (printArg(args), 0)... };
	cout << endl;
}

int main()
{
	fun(1, 1.1, std::string("abc"));
	return 0;
}

这种展开参数包的方式，不需要通过递归终止函数，printArg不是一个递归终止函数，只是一个处理参数包中每一个参数的函数。
(printArg(args), 0)：先执行printArg(args)，再得到逗号表达式的结果0。通过初始化列表来初始化一个变长数组, {(printArg(args), 0)...}将会展开成((printArg(arg1),0),(printArg(arg2),0), (printArg(arg3),0), etc... )，最终会创建一个元素值都为0的数组。在创建数组的过程中会先执行逗号表达式前面的部分printArg(args)打印出参数，也就是说在构造int数组的过程中就将参数包展开了，这个数组的目的纯粹是为了在数组构造的过程展开参数包。

1.4 empalce相关接口函数

比较：
insert：
在这里插入图片描述
emplace：
在这里插入图片描述
emplace的使用：

int main()
{
	std::list<int> lt;
	lt.emplace_back();
	lt.emplace_back(1);
	lt.emplace_back(2);
	for (auto& e : lt)
	{
		cout << e << " ";
	}
	cout << '\n';
	return 0;
}

在这里插入图片描述
而emplace在插入自定义类型数据的时候会有区别：

struct A
{
	A(int a = 1, double b = 2)
		: _a(a)
		, _b(b)
	{}
	int _a;
	double _b;
};

int main()
{
	std::list<A> lt;
	lt.push_back({ 1, 1.0 });
	lt.emplace_back(2, 2.0);
	//lt.push_back(3, 3.0);// error
	for (auto& e : lt)
	{
		cout << e._a << endl;
	}
	cout << '\n';
	return 0;
}

上面使用push_back是先构造再拷贝构造，而使用emplace_back就可以直接构造（使用参数包）。

验证一下：
引入之前写过的string类

namespace yyh
{
	class string
	{
	public:
		typedef char* iterator;
		iterator begin()
		{
			return _str;
		}

		iterator end()
		{
			return _str + _size;
		}

		string(const char* str = "")
			: _size(strlen(str))
			, _capacity(_size)
		{
			_str = new char[_capacity + 1];// _capacity表示有效字符个数
			strcpy(_str, str);
			cout << "string(const char* str) -- 构造函数" << endl;
		}

		void swap(string& s)
		{
			std::swap(_str, s._str);
			std::swap(_size, s._size);
			std::swap(_capacity, s._capacity);
		}

		// 拷贝构造
		string(const string& s)
			: _size(strlen(s._str))
			, _capacity(s._size)
		{
			_str = new char[_capacity + 1];
			strcpy(_str, s._str);
			cout << "string(const string& s) -- 深拷贝" << endl;
		}

		// 移动构造
		string(string&& s)
		{
			cout << "string(string&& s) -- 移动拷贝" << endl;
			swap(s);
		}

		// 赋值重载
		string& operator=(const string& s)
		{
			cout << "string& operator=(string s) -- 深拷贝" << endl;
			string tmp(s);
			swap(tmp);
			return *this;
		}

		~string()
		{
			delete[] _str;
			_str = nullptr;
		}

		char& operator[](size_t pos)
		{
			assert(pos < _size);
			return _str[pos];
		}

		void reserve(size_t n)
		{
			if (n > _capacity)
			{
				char* tmp = new char[n + 1];
				strcpy(tmp, _str);
				delete[] _str;
				_str = tmp;

				_capacity = n;
			}
		}

		void push_back(char ch)
		{
			if (_size >= _capacity)
			{
				size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
				reserve(newcapacity);
			}

			_str[_size] = ch;
			++_size;
			_str[_size] = '\0';
		}

		string& operator+=(char ch)
		{
			push_back(ch);
			return *this;
		}

		const char* c_str() const
		{
			return _str;
		}
	private:
		char* _str = nullptr;
		size_t _size = 0;
		size_t _capacity = 0;
	};
}


struct A
{
	A(int a = 1, const char* str = " ")
		: _a(a)
		, _str(str)
	{}
	int _a;
	yyh::string _str;
};

push_back：
在这里插入图片描述
emplace_back：
在这里插入图片描述
总结：
如果是左值，使用push_back或者emplace_back没什么区别。

对于右值，emplace_back把构造和拷贝构造合二为一成构造函数。
但是如果没有移动拷贝效率差距会很大，emplace_back还是直接构造，但是push_back就会走深拷贝。

二、包装器function

其实包装器function就是一个类模板。先来看一段代码：

template <class F, class T>
void func(F fun, T val)
{
	static int cnt = 1;
	cout << "cnt: " << cnt++ << endl;
	cout << "&cnt: " << &cnt << endl;
}

int f1(int x)
{
	return x * 2;
}

struct f2
{
	int operator()(int x)
	{
		return x * 2;
	}
};

int main()
{
	// 函数名
	func(f1, 2);
	// 仿函数对象
	func(f2(), 2);
	// lambda表达式
	func([](int x)->int { return x * 2; }, 2);
	return 0;
}

在这里插入图片描述
可以看到以三种不同的方式调用func函数，func函数就会被实例化出三份。

包装器可以很好的解决上面的问题

2.1 function用法

在这里插入图片描述
在这里插入图片描述
如果参数是两个int的话就是：
function<int(int, int)> fun1

int f1(int x)
{
	return x * 2;
}

struct f2
{
	int operator()(int x)
	{
		return x * 2;
	}
};

class f3
{
public:
	static int muli(int x)
	{
		return x * 2;
	}

	double muld(double x)
	{
		return x * 2;
	}
};


int main()
{
	// 普通函数
	function<int(int)> fun1(f1);
	cout << fun1(2) << endl;
	// 仿函数
	function<int(int)> fun2;
	fun2 = f2();
	cout << fun2(2) << endl;
	// lambda表达式
	function<int(int)> fun3;
	fun3 = [](int x)->int {return 2 * x; };
	cout << fun3(2) << endl;
	// 静态成员函数指针
	function<int(int)> fun4 = &f3::muli;
	cout << fun4(2) << endl;
	// 非静态成员函数指针
	function<int(f3/*this指针*/, int)> fun5 = &f3::muld;
	cout << fun5(f3(), 2) << endl;
	return 0;
}

在这里插入图片描述
这里要注意类成员函数的调用方法：
对于静态成员函数，因为没有this指针，所以正常调用，后面也可以不加&
对于非静态成员函数，因为含有this指针，而this指针不能显示传递，所以要传递对象。必须加&。
当然也可以不在()内部加上对象，可以使用lambda表达式中的[]捕获：

f3 ff;
function<int(int)> fun6 = [&ff](int x)->double {return ff.muld(x); };

2.2 例题：逆波兰表达式求值

题目链接
具体做法就不多叙述，这里主要展示怎么使用function函数：

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<int> st;
        map<string, function<int(int, int)>> hash = 
        {
            {"+", [](int x, int y)->int{return x + y;}},
            {"-", [](int x, int y)->int{return x - y;}},
            {"*", [](int x, int y)->int{return x * y;}},
            {"/", [](int x, int y)->int{return x / y;}},
        };
        for(auto& e : tokens)
        {
            if(hash.count(e) == 0)
            {
                st.push(stoi(e));
            }
            else
            {
                int right = st.top();
                st.pop();
                int left = st.top();
                st.pop();
                st.push(hash[e](left, right));
            }
        }
        return st.top();
    }
};

2.3 验证

在2.1中我们看道以那种方式会实例化三个模板函数。
而我们可以用function来解决这个问题：

template <class F, class T>
T func(F fun, T val)
{
	static int cnt = 1;
	cout << "cnt: " << cnt << endl;
	cout << "&cnt: " << &cnt << endl;
	return fun(val);
}

int f1(int x)
{
	return x * 2;
}

struct f2
{
	int operator()(int x)
	{
		return x * 2;
	}
};

class f3
{
public:
	static int muli(int x)
	{
		return x * 2;
	}

	double muld(double x)
	{
		return x * 2;
	}
};


int main()
{
	// 函数名
	func(function<int(int)>(f1), 2);
	// 仿函数对象
	f2 ff;
	func(function<int(int)>(ff), 2);
	// lambda表达式
	func(function<int(int)>([](int x)->int {return x * 2; }), 2);
	return 0;
}

在这里插入图片描述
可以看出只实例化出了一份函数。

三、绑定函数bind

在这里插入图片描述

3.1 调整参数顺序

int Plus(int a, int b)
{
	return a - b;
}

int main()
{
	function<int(int, int)> fun1 = bind(Plus, placeholders::_1, placeholders::_2);
	cout << fun1(1, 2) << endl;
	function<int(int, int)> fun2 = bind(Plus, placeholders::_2, placeholders::_1);
	cout << fun2(1, 2) << endl;
	return 0;
}

在这里插入图片描述
从这里就可以看出_1代表第一个参数，_2代表第二个参，对于fun2就相当于把传参的顺序改变了。

3.2 固定绑定参数

class fun
{
public:
	static int muli(int x)
	{
		return x * 2;
	}

	double muld(double x)
	{
		return x * 2;
	}
};

int main()
{
	// 非静态成员函数指针
	function<int(fun/*this指针*/, int)> fun1 = &fun::muld;
	cout << fun1(fun(), 2) << endl;
	return 0;
}

上面说过了使用非静态成员函数的时候得传递对象进去。如果我们不想传递这个参数呢？

class fun
{
public:
	static int muli(int x)
	{
		return x * 2;
	}

	double muld(double x)
	{
		return x * 2;
	}
};

int main()
{
	// 非静态成员函数指针
	function<int(fun/*this指针*/, int)> fun1 = &fun::muld;
	cout << fun1(fun(), 2) << endl;
	// 绑定参数
	function<int(int)> fun2 = bind(&fun::muld, fun(), std::placeholders::_1);
	cout << fun2(2) << endl;
	return 0;
}

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mfbz.cn/a/1828.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Docker入门到放弃笔记之容器

Docker入门到放弃笔记之容器

1、启动容器1.1容器hello world1.2 容器bash终端1.3 后台运行容器是 Docker 三大核心概念之一&#xff0c;其余两个是镜像与仓库。本文主讲容器。简单的说&#xff0c;容器是独立运行的一个或一组应用&#xff0c;以及它们的运行态环境。对应的&#xff0c;虚拟机可以理解为模拟…
阅读更多...
端口镜像讲解

端口镜像讲解

目录 端口类型 镜像方向 观察端口位置 端口镜像实现方式 流镜像 Vlan镜像 MAC镜像 配置端口镜像 配置本地观察端口 配置远程流镜像&#xff08;基于流镜像&#xff09; 端口镜像是指将经过指定端口的报文复制一份到另一个指定端口&#xff0c;便于业务监控和故障定位…
阅读更多...
【C++学习】模板进阶——非类型模板参数 | 模板的特化 | 分离编译

【C++学习】模板进阶——非类型模板参数 | 模板的特化 | 分离编译

&#x1f431;作者&#xff1a;一只大喵咪1201 &#x1f431;专栏&#xff1a;《C学习》 &#x1f525;格言&#xff1a;你只管努力&#xff0c;剩下的交给时间&#xff01; 模板我们之前一直都在使用&#xff0c;尤其是在模拟STL容器的时候&#xff0c;可以说&#xff0c;模板…
阅读更多...
CMSIS-RTOS2 RTX5移植到GD32L233

CMSIS-RTOS2 RTX5移植到GD32L233

1、CMSIS-RTOS2是什么&#xff1f; 关于CMSIS-RTOS2的官方描述如下&#xff1a; CMSIS-RTOS v2 &#xff08;CMSIS-RTOS2&#xff09; 为基于 Arm Cortex 处理器的设备提供通用 RTOS 接口。它为需要RTOS功能的软件组件提供了一个标准化的API&#xff0c;因此为用户和软件行业带…
阅读更多...
JavaWeb《三》Request请求转发与Response响应

JavaWeb《三》Request请求转发与Response响应

&#x1f34e;道阻且长&#xff0c;行则将至。&#x1f353; 本文是javaweb的第三篇&#xff0c;介绍了Request请求转发与Response响应。 上一篇&#xff1a;JavaWeb《二》Servlet、Request请求 下一篇&#xff1a;敬请期待 目录一、Request请求转发&#x1f34f;二、Response对…
阅读更多...
FPGA基于RIFFA实现PCIE采集ov5640图像传输，提供工程源码和QT上位机

FPGA基于RIFFA实现PCIE采集ov5640图像传输，提供工程源码和QT上位机

目录1、前言2、RIFFA理论基础3、设计思路和架构4、vivado工程详解5、上板调试验证并演示6、福利&#xff1a;工程代码的获取1、前言 PCIE是目前速率很高的外部板卡与CPU通信的方案之一&#xff0c;广泛应用于电脑主板与外部板卡的通讯&#xff0c;PCIE协议极其复杂&#xff0c…
阅读更多...
探索css渐变-实现饼图-加载图-灯柱

探索css渐变-实现饼图-加载图-灯柱

文章目录linear-gradient()线性渐变radial-gradient()圆形渐变conic-gradient() 锥形渐变锥形渐变实现加载动画渐变实现发廊灯柱css的渐变分为三种&#xff1a; 线性渐变&#xff1a;linear-gradient() 圆形渐变&#xff1a;radial-gradient() 锥形渐变&#xff1a;conic-gradi…
阅读更多...
C#等高级语言运行过程

C#等高级语言运行过程

C#等高级语言运行流程&#xff1a;假设您编写了一个 C# 程序并将其保存在一个称为源代码的文件中。特定于语言的编译器将源代码编译成 MSIL&#xff08;Microsoft 中间语言&#xff09;&#xff0c;也称为 CIL&#xff08;通用中间语言&#xff09;或 IL&#xff08;中间语言&a…
阅读更多...
Python基础总结

Python基础总结

目录 Python数据容器 list(列表) tuple(元祖) str(字符串) 数据容器(序列)的切片 set(集合) dict(字典、映射) 数据容器对比&#xff1a; Python函数 多个返回值&#xff1a; 函数多种传参&#xff1a; 匿名函数&#xff1a; lambda匿名函数&#xff1a; Python文…
阅读更多...
小菜鸟Python历险记：(第四集)

小菜鸟Python历险记：(第四集)

今天写的文章是记录我从零开始学习Python的全过程。在Python中函数是非常重要的&#xff0c;这里也可以称为方法。在前面分享的几篇文章中用到的方法有print(),str(),int().这些都是方法&#xff0c;而除了上面写的这几种内置方法以外&#xff0c;我们也可以自己在程序中自定义…
阅读更多...
Java分布式事务（九）

Java分布式事务（九）

文章目录&#x1f525;XA强一致性分布式事务实战_Atomikos介绍&#x1f525;XA强一致性分布式事务实战_业务说明&#x1f525;XA强一致性分布式事务实战_项目搭建&#x1f525;XA强一致性分布式事务实战_多数据源实现&#x1f525;XA强一致性分布式事务实战_业务层实现&#x1…
阅读更多...
JS判断是否为base64字符串如何转换为图片src格式

JS判断是否为base64字符串如何转换为图片src格式

需求背景 &#xff1a; 如何判断后端给返回的 字符串 是否为 base-64 位 呢 &#xff1f; 以及如果判断为是的话&#xff0c;如何给它进行转换为 img 标签可使用的那种 src 格式 呢 &#xff1f; 1、判断字符串是否为 base64 以下方法&#xff0c;可自行挨个试试&#xff0c;…
阅读更多...
蓝桥杯倒计时 | 倒计时20天

蓝桥杯倒计时 | 倒计时20天

作者&#x1f575;️‍♂️&#xff1a;让机器理解语言か 专栏&#x1f387;&#xff1a;蓝桥杯倒计时冲刺 描述&#x1f3a8;&#xff1a;蓝桥杯冲刺阶段&#xff0c;一定要沉住气&#xff0c;一步一个脚印&#xff0c;胜利就在前方&#xff01; 寄语&#x1f493;&#xff1a…
阅读更多...
第十四届蓝桥杯三月真题刷题训练——第 16 天

第十四届蓝桥杯三月真题刷题训练——第 16 天

目录 第 1 题&#xff1a;英文字母 问题描述 输入格式 输出格式 样例输入 1 样例输出 1 样例输入 2 样例输出 2 评测用例规模与约定 运行限制 代码&#xff1a; 第 2 题&#xff1a;单词分析 题目描述 输入描述 输出描述 输入输出样例 运行限制 数组代码&…
阅读更多...
【MySQL】聚合查询

【MySQL】聚合查询

目录 1、前言 2、插入查询结果 3、聚合查询 3.1 聚合函数 3.1.1 count 3.1.2 sum 3.1.3 avg 3.1.4 max 和 min 4、GROUP BY 子句 5、HAVING 关键字 1、前言 前面的内容已经把基础的增删改查介绍的差不多了&#xff0c;也介绍了表的相关约束&#xff0c; 从本期开始…
阅读更多...
C语言实现队列(Push Pop Size Front EmptyBack)

C语言实现队列(Push Pop Size Front EmptyBack)

队列是一个重要的数据结构&#xff0c;他的特性是先进先出&#xff0c;所以由于这个特性&#xff0c;队列只有一个入口和一个出口&#xff0c;所以只有push和pop 下面我们看一下他如何实现 首先我们来看一下他的结构体 这里我们看到我们定义了两个结构体&#xff0c;其中一个…
阅读更多...
关于多层板，你了解多少？

关于多层板，你了解多少？

01 前言 大家好&#xff0c;我是张巧龙。好久没写原创了&#xff0c;记得之前刚接触PCB时&#xff0c;还在用腐蚀单层板&#xff0c;类似这种。 慢慢随着电子产品功能越来越多&#xff0c;产品越来越薄&#xff0c;对PCB设计要求越来越高了&#xff0c;复杂程度也随之增加。因此…
阅读更多...
第十四届蓝桥杯三月真题刷题训练——第 17 天

第十四届蓝桥杯三月真题刷题训练——第 17 天

目录 第 1 题&#xff1a;ASC 运行限制 代码&#xff1a; 第 2 题&#xff1a;递增三元组_双指针_long 输出描述 输入输出样例 运行限制 代码&#xff1a; 第 3 题&#xff1a;环境治理 代码&#xff1a; 第 4 题&#xff1a;小球称重 代码&#xff1a; 第 1 题&a…
阅读更多...
小白学Pytorch系列--Torch API (7)

小白学Pytorch系列--Torch API (7)

小白学Pytorch系列–Torch API (7) Comparison Ops allclose 此函数检查输入和其他是否满足条件&#xff1a; >>> torch.allclose(torch.tensor([10000., 1e-07]), torch.tensor([10000.1, 1e-08])) False >>> torch.allclose(torch.tensor([10000., 1e-…
阅读更多...
48天强训 Day1 JavaOj

48天强训 Day1 JavaOj

48天强训 & Day1 & JavaOj 1. 编程题1 - 组队竞赛 组队竞赛_牛客笔试题_牛客网 (nowcoder.com) 1.1 读题 1.2 算法思想基础 我们应该尽量的让每一个队伍的中间值都最大化~我们应该尽量的让每一个队伍的最小值都足够小~前33%的不应该都作为每个队伍的最大值~ 接下来…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站