【C++】C++11（万能模版、完美转发，可变参数模版，lambda表达式，包装器function+bind绑定）

已于 2023-10-07 17:38:35 修改
阅读量914 收藏 4
点赞数
分类专栏： C++ 文章标签： c++ 开发语言
于 2023-10-07 17:38:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67821824/article/details/133638245
版权

前言：

       我们上一章一节已经接触了C++11的一些特性，本章将继续更深入介绍C++11中其他使用且重要的一些功能。

目录

（一）万能模版和完美转发

1、万能模版

2、完美转发

（二）可变参数模版

1、可变参数模版的使用

2、emplace_back

（三）lambda表达式

1、引入

2、lambda表达式的定义

3、lambda表达式的用法

（四）包装器function及bind绑定

1、包装器

 2、bind绑定

（一）万能模版和完美转发

1、万能模版

万能模版样式：

  • 模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值
  • 模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力
  • 但是引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值

 这里还是太抽象，我们来看一个例子：
 


void Fun(int& x) { cout << "左值引用" << endl; }
void Fun(const int& x) { cout << "const 左值引用" << endl; }

void Fun(int&& x) { cout << "右值引用" << endl; }
void Fun(const int&& x) { cout << "const 右值引用" << endl; }
// 模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值。
// 模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力，
// 但是引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值，
// 我们希望能够在传递过程中保持它的左值或者右值的属性, 就需要用我们下面学习的完美转发
template<typename T>
void PerfectForward(T&& t)
{
	Fun(t);
}
int main()
{
	PerfectForward(10); // 右值
	int a;
	PerfectForward(a); // 左值
	PerfectForward(std::move(a)); // 右值
	const int b = 8;
	PerfectForward(b); // const 左值
	PerfectForward(std::move(b)); // const 右值
	return 0;
}

这段代码的输出结果是：

输出全是左值引用，很显然这并不是我们想要的，因为无论传的是左值还是右值，都将退化成左值。

那怎么解决这一问题呢？？？这就要用到了我们下面讲解的完美转发。

2、完美转发

我们为了解决类似上述场景的问题，希望能够在传递过程中保持它的左值或者右值的属性, 就需要用我们下面学习的：

完美转发：

这里就用到了我们forward的函数模板。

沿用上面的例子我们来看：


void Fun(int& x) { cout << "左值引用" << endl; }
void Fun(const int& x) { cout << "const 左值引用" << endl; }

void Fun(int&& x) { cout << "右值引用" << endl; }
void Fun(const int&& x) { cout << "const 右值引用" << endl; }

//std::forward<T>(t)在传参的过程中保持了t的原生类型属性。

template<typename T>
void PerfectForward(T&& t)
{
	//完美转发，按照原封不动的方式进行转发
	//Fun(t);
	Fun(std::forward<T>(t));
}

int main()
{
	PerfectForward(10);           //右值

	int a;
	PerfectForward(a);            //左值
	PerfectForward(std::move(a)); //右值

	const int b = 8;
	PerfectForward(b);		      //const 左值
	PerfectForward(std::move(b)); //const 右值

	return 0;
}

 运行结果：

C++11新提供的forward函数模板，可以解决上述问题，使得传右值不会退化成左值。

（二）可变参数模版

1、可变参数模版的使用

首先在学C语言的时候，我们用的printf函数是一个可变参数函数，printf从语法上说是可以写多个参数，然后该函数自己识别。

可变参数模版：

解释：

  • Args是一个模板参数包，args是一个函数形参参数包
  • 声明一个参数包Args…args，这个参数包中可以包含0到任意个模板参数
上面的参数 args 前面有省略号，所以它就是一个可变模版参数，我们把带省略号的参数称为 “ 参数
包 ” ，它里面包含了 0 到 N （ N>=0 ）个模版参数。我们无法直接获取参数包 args 中的每个参数的，
只能通过展开参数包的方式来获取参数包中的每个参数，这是使用可变模版参数的一个主要特
点，也是最大的难点，即如何展开可变模版参数。由于语法不支持使用 args[i] 这样方式获取可变
参数，所以我们的用一些奇招来一一获取参数包的值。

首先，我们介绍如何参数个数的方法：

template <class ...Args>
void ShowList1(Args... args)
{
	//参数个数
	cout << sizeof...(args) << endl;
}

//不一定非要用Args也可以取别的名字
template <class ...X>
void ShowList2(X... y)
{
	cout << sizeof...(y) << endl;
}

int main()
{
	ShowList1(1, 'x', 1.1);
	ShowList2(1, 2, 3, 4, 5);

	return 0;
}

主要使用sizeof...( )形式来获取参数个数。

那么我们怎么一一获取参数包的值的呢？有下面两种方法：

1、递归函数方式展开参数包 
// 递归终止函数
template <class T>
void ShowList(const T& t)
{
 cout << t << endl;
}
// 展开函数
template <class T, class ...Args>
void ShowList(T value, Args... args)
{
 cout << value <<" ";
 ShowList(args...);
}
int main()
{
 ShowList(1);
 ShowList(1, 'A');
 ShowList(1, 'A', std::string("sort"));
 return 0;
}
  • 类似于递归的一个过程，但是不是递归，最后都有一个结束条件，参数包中的模板参数是一个一个减少的。
  • 整个推导的过程是在编译的时候进行的（这是个编译的过程 – 编译时决议）

2、逗号表达式展开参数包

template <class T>
void PrintArg(T t)
{
 cout << t << " ";
}
//展开函数
template <class ...Args>
void ShowList(Args... args)
{
 int arr[] = { (PrintArg(args), 0)... };
 cout << endl;
}
int main()
{
 ShowList(1);
 ShowList(1, 'A');
 ShowList(1, 'A', std::string("sort"));
 return 0;
}
解释：
这种展开参数包的方式，不需要通过递归终止函数，是直接在expand函数体中展开的, printarg
不是一个递归终止函数，只是一个处理参数包中每一个参数的函数。这种就地展开参数包的方式
实现的关键是逗号表达式。我们知道逗号表达式会按顺序执行逗号前面的表达式。
expand函数中的逗号表达式：(printarg(args), 0)，也是按照这个执行顺序，先执行
printarg(args)，再得到逗号表达式的结果0。同时还用到了C++11的另外一个特性——初始化列
表，通过初始化列表来初始化一个变长数组, {(printarg(args), 0)...}将会展开成((printarg(arg1),0),
(printarg(arg2),0), (printarg(arg3),0), etc... )，最终会创建一个元素值都为0的数组int arr[sizeof...
(Args)]。由于是逗号表达式，在创建数组的过程中会先执行逗号表达式前面的部分printarg(args)
打印出参数，也就是说在构造int数组的过程中就将参数包展开了，这个数组的目的纯粹是为了在
数组构造的过程展开参数包。
输出结果如下：

2、emplace_back

首先我们看到的emplace系列的接口，支持模板的可变参数，并且万能引用。那么相对insert和
emplace系列接口的优势到底在哪里呢？

  • emplace_back支持可变参数，拿到构建pair对象的参数后自己去创建对象
  • 那么在这里我们可以看到除了用法上，和push_back没什么太大的区别
  • 可以不传pair，可以直接传参数
  • 拿到参数自己构建对象（保证了底层一定是右值 —— 直接去构造的）
     

 对比：

push_back()：

  • 参数如果给的是左值是：构造 + 拷贝构造
  • 参数如果给的是右值是：构造 + 移动构造
  • 函数传值返回也是个右值

emplace_back()：

  • 直接构造

两者的底层实现的机制不同。push_back() 向容器尾部添加元素时，首先会创建这个元素，然后再将这个元素拷贝或者移动到容器中（如果是拷贝的话，事后会自行销毁先前创建的这个元素）；而 emplace_back() 在实现时，则是直接在容器尾部创建这个元素，省去了拷贝或移动元素的过程。但其实两者差别并不大。

（三）lambda表达式

1、引入

C++98中，我们会遇到下面这种场景：

如果想要对一个数据集合中的元素进行排序，可以使用std::sort方法 
#include <algorithm>
#include <functional>
int main()
{
int array[] = {4,1,8,5,3,7,0,9,2,6};
// 默认按照小于比较，排出来结果是升序
std::sort(array, array+sizeof(array)/sizeof(array[0]));
// 如果需要降序，需要改变元素的比较规则
std::sort(array, array + sizeof(array) / sizeof(array[0]), greater<int>());
return 0;
}
如果待排序元素为自定义类型，需要用户定义排序时的比较规则： 
struct Goods
{
 string _name;  // 名字
 double _price; // 价格
 int _evaluate; // 评价
 Goods(const char* str, double price, int evaluate)
 :_name(str)
 , _price(price)
 , _evaluate(evaluate)
 {}
};
struct ComparePriceLess
{
 bool operator()(const Goods& gl, const Goods& gr)
 {
 return gl._price < gr._price;

 }
};
struct ComparePriceGreater
{
 bool operator()(const Goods& gl, const Goods& gr)
 {
 return gl._price > gr._price;
 }
};
int main()
{
 vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2, 
3 }, { "菠萝", 1.5, 4 } };
 sort(v.begin(), v.end(), ComparePriceLess());
sort(v.begin(), v.end(), ComparePriceGreater());
}
人们开始觉得上面的写法太复杂了，每次为了实现一个algorithm算法，
都要重新去写一个类，如果每次比较的逻辑不一样，还要去实现多个类，特别是相同类的命名，
这些都给编程者带来了极大的不便。因此，在C++11语法中出现了Lambda表达式。

2、lambda表达式的定义

定义了一个可以调用的对象 / 匿名函数，一般定义在局部，特点是可以深度绑定了局部的数据。

  • lambda表达式，实际上是一个匿名函数，实际上是在定义一个函数（局部的函数）
  • lambda表达式通常是用来定义小函数
  • lambda表达式在局部是很好用的，最特别的就是捕捉列表

auto Add1 = [](int x, int y)->int{return x + y; }; Add叫lambda表达式的对象 – lambda定义的是一个对象。

lambda表达式书写格式：[capture-list] (parameters) mutable -> return-type { statement }
lambda表达式各部分说明：
  • [capture-list] : 捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[]来判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda 函数使用。
  • (parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以 连同()一起省略
  • mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。使用该修饰符时，参数列表不可省略(即使参数为空)。
  • ->returntype：返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推 导。
  • {statement}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量。

注意：

  • 在lambda函数定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为空。
  • 因此C++11中最简单的lambda函数为：[]{}; 该lambda函数不能做任何事情。

3、lambda表达式的用法

int main()
{
	int a = 0, b = 200;
	
	//一般是局部匿名函数  也可以写到全局（一般都不写返回值）
	//参数列表（无参的时候）和返回值（表达式自动推导）也可以省略掉
	auto Add1 = [](int x, int y)->double {return (x + y) / 3.0; };
	auto Add2 = [](int x, int y)->int {return (x + y) / 3.0; };

	//参数列表可以省略了
	auto Add3 = [a, b] {return (a + b) / 3.0; };

	//调用是和普通的函数一样的
	cout << Add1(a, b) << endl;
	cout << Add2(a, b) << endl;

	//调用没有区别，但是没有实参，因为捕捉了
	cout << Add3() << endl;
}
  • 一般是局部匿名函数 也可以写到全局（一般都不写返回值）
  • 参数列表（无参的时候）和返回值类型（表达式自动推导）也可以省略掉
  • 和普通函数调用没区别，但是没有实参，因为捕捉了

捕捉列表的用法：

用lambda表达式来实现交换两个数：

int main()
{
	int a = 0, b = 200;

	//方法一：
	auto Swap1 = [](int& x, int& y)->void {
		int tmp = x;
		x = y;
		y = tmp;
	};

	Swap1(a, b);
	cout << a << " " << b << endl;

	//方法二：
	//mutable 只是让传值捕捉变量const属性去掉了
	//mutable要和()参数列表配在一起
	//可以认为里面的a，b还是外面a，b的拷贝 -- 里面改变外面还是不变
	//所以mutable实际没什么价值
	//这样写还是没有交换 -- 只是编译通过了但是达不到我们想要的效果
	//auto Swap2 = [a, b]()mutable->void {
	//	int tmp = a;
	//	a = b;
	//	b = tmp;
	//};

	//用引用的方式捕捉（按值捕捉不能改变）
	auto Swap2 = [&a, &b]()->void {
		int tmp = a;
		a = b;
		b = tmp;
	};

	Swap2();
	cout << a << " " << b << endl;
}

方法一：

  • 就像普通函数那样传引用传参

方法二：

  • 不能通过传值传参，首先捕捉列表捕捉的数据具有const属性，不能修改
  • 其次mutable可以让传值捕捉变量const属性去掉了，即使去掉了
  • mutable要和()参数列表配在一起
  • 所以mutable实际没什么价值
  • 可以认为里面的a，b还是外面a，b的拷贝 ，里面改变外面还是不变

所以只能按照引用的方式捕捉
 

各种混合捕捉：
 

int main()
{
	int c = 2, d = 3, e = 4, f = 5, g = 6, ret;

	//传值的方式捕捉全部对象
	auto Func1 = [=] {
		return c + d * e / f + g;
	};

	cout << Func1() << endl;

	//传引用捕捉全部对象
	auto Func2 = [&] {
		ret = c + d * e / f + g;
	};

	Func2();
	cout << ret << endl;

	//混着捕捉
	auto Func3 = [c, d, &ret] {
		ret = c + d;
	};

	Func3();
	cout << ret << endl;

	//ret传引用捕捉 其他全部传值捕捉
	auto Func4 = [=, &ret] {
		ret = c + d * e / f + g;

		//传值捕捉默认是加了const的
		//c = 1;
	};

	Func4();
	cout << ret << endl;

	return 0;
}

每一个lambda表达式类型名字不一样：

int main()
{
	auto Add = [](int x, int y)->int { return x + y; };

	cout << typeid(Add).name() << endl;
	return 0;
}

仿函数的名称后面叫uuid，一组随机字符串，通过某个算法得到的，使得每个lambda表达式的名字都不同。

注意：

lambda表达式之间不能相互赋值。

void (*PF)();
int main()
{
 auto f1 = []{cout << "hello world" << endl; };
 auto f2 = []{cout << "hello world" << endl; };
  
 //f1 = f2;   // 编译失败--->提示找不到operator=()
    // 允许使用一个lambda表达式拷贝构造一个新的副本
 auto f3(f2);
 f3();
 // 可以将lambda表达式赋值给相同类型的函数指针
 PF = f2;
 PF();
 return 0;
}

（四）包装器function及bind绑定

1、包装器

function包装器 也叫作适配器。C++中的function本质是一个类模板，也是一个包装器。

模板参数说明：

  • Ret: 被调用函数的返回类型
  • Args…： 被调用函数的形参

看下面一段程序：

template<class F, class T>
T useF(F f, T x)
{
	static int count = 0;
	cout << "count:" << ++count << endl;
	cout << "count:" << &count << endl;

	return f(x);
}

double f(double i)
{
	return i / 2;
}

struct Functor
{
	double operator()(double d)
	{
		return d / 3;
	}
};

int main()
{
	//函数名
	cout << useF(f, 11.11) << endl;
	//函数对象
	cout << useF(Functor(), 11.11) << endl;
	//lamber表达式
	cout << useF([](double d)->double{ return d / 4; }, 11.11) << endl;

	return 0;
}
通过上面的程序验证，我们会发现useF函数模板实例化了三份。
  • func可能是函数名？函数指针？函数对象(仿函数对象)？也有可能是lamber表达式对象？
  • 所以这些都是可调用的类型！

如此丰富的类型，可能会导致模板的效率低下！

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


#include <functional>
template<class F, class T>
T useF(F f, T x)
{
	static int count = 0;
	cout << "count:" << ++count << endl;
	cout << "count:" << &count << endl;
	return f(x);
}
double f(double i)
{
	return i / 2;
}
struct Functor
{
	double operator()(double d)
	{
		return d / 3;
	}
};
int main()
{// 函数名
	std::function<double(double)> func1 = f;
	cout << useF(func1, 11.11) << endl;
	// 函数对象
	std::function<double(double)> func2 = Functor();
	cout << useF(func2, 11.11) << endl;
	// lamber表达式
	std::function<double(double)> func3 = [](double d)->double { return d /
		4; };
	cout << useF(func3, 11.11) << endl;
	return 0;
}

  • function可以认为是一个类模板，包装可调用对象
  • 经过包装器包装之后得到的都是一个统一的类型function
  • 最后count的地址相同，并且count到3了，说明包装器是统一了类型

注意，特殊的包装：

 2、bind绑定

简介：

std::bind函数定义在头文件中，是一个函数模板，它就像一个函数包装器(适配器)，接受一个可调用对象（callable object），生成一个新的可调用对象来“适应”原对象的参数列表。 一般而言，我们用它可以把一个原本接收N个参数的函数fn，通过绑定一些参数，返回一个接收M个（M可以大于N，但这么做没什么意义）参数的新函数。同时，使用std::bind函数还可以实现参数顺序调整等操作。

可以将bind函数看作是一个通用的函数适配器，它接受一个可调用对象，生成一个新的可调用对象来“适应”原对象的参数列表。

bind是个函数模板，调整了调用对象参数，用来调整个数和顺序，生成一个新的可调用对象：

包装器的特点就是统一了类型，但是值得注意的是包装时一定要注意匹配，如下：

这就在包装时不匹配，所在包装时一定要匹配。

下面的场景我们存一个map，这时就要求function包装器要统一了：

不过不免会有一些特殊情况：


func1和func2是可以的，但是func3就难受了呀，不匹配啊…

此时我们就可以通过bind函数来调整一下参数个数：

还可以调整参数顺序：

 

 详细代码：

#include <functional>
int Plus(int a, int b)
{
	return a + b;
}
class Sub
{
public:
	int sub(int a, int b)
	{
		return a - b;
	}
};
int main()
{
	//表示绑定函数plus 参数分别由调用 func1 的第一，二个参数指定
	std::function<int(int, int)> func1 = std::bind(Plus, placeholders::_1,
		placeholders::_2);
	//auto func1 = std::bind(Plus, placeholders::_1, placeholders::_2);
	//func2的类型为 function<void(int, int, int)> 与func1类型一样
	//表示绑定函数 plus 的第一，二为： 1， 2
	auto func2 = std::bind(Plus, 1, 2);
	cout << func1(1, 2) << endl;
	cout << func2() << endl;
	Sub s;
	// 绑定成员函数
	std::function<int(int, int)> func3 = std::bind(&Sub::sub, s,
		placeholders::_1, placeholders::_2);
	// 参数调换顺序
	std::function<int(int, int)> func4 = std::bind(&Sub::sub, s, 
	placeholders::_2, placeholders::_1);
	cout << func3(1, 2) << endl;
	cout << func4(1, 2) << endl;
	return 0;
}

实际例子：


int Div(int a, int b)
{
	return a / b;
}

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

int Mul(int a, int b, double rate)
{
	return a * b * rate;
}

class Sub
{
public:
	int sub(int a, int b)
	{
		return a - b;
	}
};

using namespace placeholders;

// 11:50继续
int main()
{
	// 调整个数, 绑定死固定参数
	function<int(int, int)> funcPlus = Plus;
	//function<int(Sub, int, int)> funcSub = &Sub::sub;
	function<int(int, int)> funcSub = bind(&Sub::sub, Sub(), _1, _2);
	function<int(int, int)> funcMul = bind(Mul, _1, _2, 1.5);
	map<string, function<int(int, int)>> opFuncMap =
	{
		{ "+", Plus},
		{ "-", bind(&Sub::sub, Sub(), _1, _2)}
	};

	cout << funcPlus(1, 2) << endl;
	cout << funcSub(1, 2) << endl;
	cout << funcMul(2, 2) << endl;

	cout << opFuncMap["+"](1, 2) << endl;
	cout << opFuncMap["-"](1, 2) << endl;



	int x = 2, y = 10;
	cout << Div(x, y) << endl;

	// 调整顺序 -- 鸡肋
	// _1 _2.... 定义在placeholders命名空间中，代表绑定函数对象的形参，
	// _1，_2...分别代表第一个形参、第二个形参...
	//bind(Div, placeholders::_1, placeholders::_2);
	//auto bindFunc1 = bind(Div, _1, _2);
	//function<int(int, int)> bindFunc2 = bind(Div, _2, _1);
	//cout << bindFunc1(x, y) << endl;
	//cout << bindFunc2(x, y) << endl;



	return 0;
}

感谢您的阅读！

朱C.
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++11 function 委托机制 观察者模式，适用于界面开发，lambda表达式
03-22
使用C++11 编写的一个委托模板类，适用于界面开发的观察者模式，OnInitDialog中add，OnDestroy中remove
浅谈C++11新引入的lambda表达式
08-29
C++11中的Lambda表达式是一种强大的编程工具，它允许程序员在代码中定义匿名函数，即没有名称的函数。Lambda表达式简洁、易读，尤其适用于编写短小、临时性的函数，如回调函数或作为算法的迭代器。它们的引入显著...
C++11：模板（可变模板参数）
you_fathe的博客
08-16 3442
介绍C++ 模板的用法和C++11新特性：可变参数模板
C++11新特性数量不定的模板参数
QQ845264718
05-23 1352
什么叫数量不定的模板参数呢？请看下面的例子 #include <iostream> using namespace std; void print()//递归的出口 { //空实现 } template<typename T, typename... Types> void print(const T& firstArg, const Types&... args) { cout << firstArg << endl; prin
【C++】C++11可变参数模板
最新发布
℉f的博客
04-09 2298
其实我们之前经常使用可变参数模板，C语言的printf函数大家一定非常熟悉，其实这就是一种可变参数模板：那么在C++11引入可变参数模板的设计可以带来什么变化呢？让我们一起来学习下吧！
C++11 模板用法总结
灰太狼的小秘密
07-06 1815
1.1 简介 C++提供了两种模板机制，函数模板和类模板。 使用范围：模板的声明或定义**只能在全局或类范围进行**，不能在局部范围（如函数）内进行。 使用目的：使用模板是为了能够让程序员**编写与类型无关的代码。 函数模板和模板函数区别**：函数模板是一个模板，其中用到通用类型参数，不能直接执行；模板函数是一个具体的函数，它是一个具体执行的函数，由编译系统在遇到具体函数调用时生成，可执行。 1.2 函数模板 1.2.1 函数模板格式 template <类型形参表或称模板参数列表&gt
【 C++11 】可变参数模板
bit_zyx的博客
10-15 3332
目录 1、可变参数模板的概念 2、参数包的展开方式 递归函数方式展开参数包 逗号表达式展开参数包 3、STL容器中的empalce相关接口函数
C++11可变参数模板
xungen的博客
05-02 806
点击查看完整代码 C++11支持可变参数模板，可以代替C语言中的va_list实现类型安全的可能参数函数（比如printf函数）。下面用C++11可变参数模板实现支持多个参数的求和函数与求平均值函数。 定义单个参数求和函数（用于终止模板递归展开） template<class DATA_TYPE> static DATA_TYPE sum(DATA_TYPE val) { ...
一文读懂c++11 Lambda表达式
01-19
C++11新增了很多特性，Lambda表达式（Lambda expression）就是其中之一，很多语言都提供了 Lambda 表达式，如 Python，Java ，C#等。本质上， Lambda 表达式是一个可调用的代码单元[1]^{[1]}[1]。实际上是一个闭包...
C++11中lambda、std::function和std:bind详解
08-31
大家都知道C++11中增加了许多的新特性，下面在这篇文中我们就来聊一下lambda表达式，闭包，std::function以及std::bind。文中介绍的很详细，相信对大家具有一定的参考价值，有需要的朋友们下面来一起看看吧。
现代C++之万能引用、完美转发、引用折叠
Francis的博客
11-27 214
现代C++之万能引用、完美转发、引用折叠0.导语1.问题引入2.引入万能引用3.万能引用出现场合4.理解左值与右值4.1 精简版4.2 完整版4.3 生命周期延长4.4 生命周期延长应用5.区分万能引用6.表达式的左右值性与类型无关7.引用折叠和完美转发7.1 引用折叠之本质细节7.2 示例与使用7.3 std::move()与std::forward()源码剖析8.不要返回本地变量的引用9.总结...
C++万能头文件 stdc++.h
11-11
C++万能头文件 "stdc++.h" : 头文件中包含了 "#define _CRT_SECURE_NO_WARNINGS" 预处理语句用来去除VS所有警告信息的显示， 如不需要可以自行精简删除。
C++11标准模板（STL）- 算法 - 最小/最大操作（std::minmax）
qq_40788199的博客
12-17 939
返回给定值的最小和最大者。 1-2) 返回到 a 的 b 较小和较大者的引用。 3-4) 返回 initializer_list ilist 中值的最小和最大者。 (1,3) 版本用 operator< 比较值，而 (2,4) 版本用给定的比较函数 comp 。
万能引用和完美转发
qq_44875284的博客
03-30 1366
介绍万能引用和完美转发及使用方法
数量不定的模板参数 C++11
欧特GO
07-18 619
#include <iostream> #include<bitset> using namespace std; void print() { cout << "The function is over!" << endl; } template <typename T,typename... Types> void print(const T& firstArg, const Types&... args) { cout
【C++】C++11新特性——可变参数模板|function|bind
qq_66314292的博客
03-20 1934
可变参数模板|function|bind
C++11_可变参数模板
yue152152的博客
10-09 1615
有了可变参数模板，你可以给函数传任意类型，任意数量的参数
C++11可变模板参数
uhlgjd的博客
04-22 199
C++11支持可变模板参数，一个函数可以传入任意多个参数，类似于C语言的printf函数。示例如下： #include<iostream> using namespace std; void print() //递归出口 {} template <typename T,typename... Types> void print(const T& firstArg,const Types&... args) { cout << firstArg &l
c++11模板类型推导规则
weixin_42923076的博客
05-07 2188
模板类型推导规则 当你准备迫切地想要了解本文的内容时，说明你对c++的了解已经比较深入了！本文将试图介绍c++11之后的模板类型推导机制是怎样的（加入右值引用概念），诚然，模板类型推导规则是了解GP（泛型编程，Generic Programming）的基础和前提，但只会这个还远远不够，泛型编程对我来说还是一个触不可及的范式；哪怕你不准备学习使用GP，模板类型推导规则仍然是一个合格的c++工程师必备的知识，模板在现代c++开发中还是很常用的！ c++的函数/类模板为我们提供了这样一种语义：可以针对多种不定的类
c++ lambda表达式参数
08-08
Lambda表达式的参数可以根据具体的需求来定义。在引用中的示例中，Lambda表达式的参数是两个float类型的变量a和b。而在引用中的示例中，Lambda表达式的参数是一个int类型的变量a。Lambda表达式的参数列表可以根据需要进行扩展和修改。在使用Lambda表达式时，需要根据具体情况来定义参数的类型和名称。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值