C++11-(2)

最新推荐文章于 2025-05-19 08:35:23 发布
最新推荐文章于 2025-05-19 08:35:23 发布
阅读量943 收藏 27
点赞数 31
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/muzi_liii/article/details/147915201
版权

文章目录

（一）C++11新增功能

1.1 引用折叠

C++中不能直接定义引用的引用，如int& && r = i ;，但是可以间接定义引用的引用，一般情况可以用typedef或者using关键字来实现

int main()
{
	//int i = 0;
	//int&&& r = i; //直接定义引用的引用是错误的

	typedef int& lref;
	using rref = int&&;
	int n = 10;
	//间接引用
	lref& r1 = n;
	lref&& r2 = n;
	rref& r3 = n;
	rref&& r4 = 1;
	return 0;
}

上面的代码中，通过模板或者typedef中的类型操作可以构成引用的引用，C++11中把这样的场景叫作引用折叠，它的折叠逻辑是，右值引用的右值引用折叠成右值引用，有左值引用的组合均被折叠成左值引用，所以代码中r1的类型是int&，r2的类型是int&，r3的类型是int&，只有r4的类型是int&&

1.1.1 在模板中使用引用折叠的场景

左值引用模板：

template<class T>
void f1(T& t) 
{ }

int main()
{
	int i = 10;

	//没有折叠，实例化->f1(int& t);
	f1<int>(i);
	f1<int>(0); //报错

	//有折叠，实例化->f1(int& t);
	f1<int&>(i);
	f1<int&&>(0); //报错

	//有折叠，实例化->f1(int& t);
	f1<int&&>(i);
	f1<int&&>(0); //报错

	//有折叠，实例化->f1(const int& t);
	f1<const int&>(i);
	f1<const int&&>(0); //被const修饰的int& 可以引用左值，也可以引用右值
	return 0;
}

右值引用模板：

template<class T>
void f2(T&& t) //右值引用的模板
{ }

int main()
{
	int i = 10;

	//没有折叠，实例化->f2(int& t);
	f2<int>(i);
	f2<int>(0); //报错

	//有折叠，实例化->f2(int& t);
	f2<int&>(i);
	f2<int&>(0); //报错

	//有折叠，实例化->f2(int&& t);
	f2<int&&>(i); //报错
	f2<int&&>(0);

	//有折叠，实例化->f2(const int& t);
	f2<const int&>(i);
	f2<const int&>(0); //被const修饰的int& 可以引用左值，也可以引用右值

	return 0;
}

总结：第一个模板为左值引用，由于折叠限定，实例化出来的都是左值引用，第二个模板为右值引用，由于折叠限定，实例化出来的可以为左值引用，也可以为右值引用，即第二个模板通常被称为“万能引用”

1.1.2 引用折叠是如何实现的

证明如下：

template<class T>
void func(T&& t) //右值引用模板
{
	int a = 0;
	T x = a;
	x++;
	std::cout << &a << std::endl;
	std::cout << &x << std::endl;
}
int main()
{
	func(10);
	//10是右值，则推导出来的T是int,实例化->func(int&& t);
	//func函数中，x++,a与x的地址不相同

	int b = 0;
	func(b);
	//b是左值，则推导出来的T是int&,实例化->func(int& t);
	//func函数中，x是a的别名，x++相当于a++,两者地址相同
	
	func(std::move(b));
	//std::move(b)是右值，则推导出来的T是int,实例化->func(int&& t);
	//func函数中，x++,a与x的地址不相同

	const int a = 11;
	func(a);
	//a是左值，则推导出来的T是const int&,实例化->func(const int& t);
	// func函数中，x是a的别名，x被const修饰不能进行赋值操作,两者地址相同
	
	func(std::move(a));
	//std::move(a)是右值，则推导出来的T是const int,实例化->func(const int&& t);
	//func函数中，x被const修饰不能进行赋值操作,两者地址不相同
	return 0;
}

总结：当实参是左值时，编译器会自动推导模板参数的类型为int&，发生引用折叠，使得左值引用均折叠成左值引用，当实参是右值时，编译器会自动推导模板参数的类型为int，不发生引用折叠，就还是右值引用

1.2 完美转发

看下面代码：

void fun(int& t) { std::cout << "左值引用" << std::endl; };
void fun(const int& t) { std::cout << "const左值引用" << std::endl; };
void fun(int&& t) { std::cout << "右值引用" << std::endl; };
void fun(const int&& t) { std::cout << "const右值引用" << std::endl; };

template<class T>
void Func(T&& t)
{
	fun(t);
}

int main()
{
	Func(10);
	//右值，推导出来的T为int，实例化->Func(int&& t);

	int a = 11;
	Func(a);
	//左值，推导出来的T为int&，实例化->Func(int& t);
	Func(std::move(a));
	//右值，推导出来的T为int，实例化->Func(int&& t);

	const int b = 22;
	Func(b);
	//左值，推导出来的T为const int&，实例化->Func(const int& t);
	Func(std::move(b));
	//右值，推导出来的T为const int，实例化->Func(const int&& t);
	return 0;
}

该代码，通过万能模板调用Func函数，然后再调用fun函数，实现根据不同的值的属性调用到对应的fun函数，如，10是右值就调用对应fun函数的右值引用；a是左值就调用对应fun函数的左值引用，我们来看运行结果

在这里插入图片描述
结果未达到我们的预期，是右值的没有匹配到对应的右值函数，这是因为，右值引用的属性还是左值，所以就会出现全是左值的情况，为了解决以上这种问题，C++11库中实现了一个功能“完美转发”，forward，该功能就是保持原来的属性，实现是左值引用的就保持左值属性，右值引用的就保持右值属性，该接口的本质实际上还是类型强转，使用方法如下：

template<class T>
void Func(T&& t)
{
	//将原代码改成这样即可
	fun(std::forward<T>(t));
}

在这里插入图片描述

1.3 lambda表达式语法

1.3.1 定义

lambda表达式本质是一个匿名函数对象，跟普通函数不同的是它可以定义在函数内部。lambda表达式对于语法使用层面而言没有类型，所以一般是用auto或者函数模板参数定义的对象去接收lambda对象

lambda表达式的格式：capture-list->return type{function body}

  • capture-list:捕捉列表，该列表总是出现在lambda函数的开始，编译器根据捕捉列表来判断接下来的代码是否为lambda函数。捕捉列表能够捕捉上下文中的变量lambda函数使用，捕捉列表可以通过传值和传引用捕捉，捕捉列表为空也不能省略
  • parmeters：参数列表。不传参时可以连同()一同省略
  • return type：返回类型，用于追踪返回类型形式声明函数的返回值类型，没有返回值时，可以省略。一般返回值类型明确的情况下，也可以省略，由编译器对返回值类型进行推导。
  • function body：函数体

用法示例：

int main()
{
	auto add = [](int x, int y)->int {return x + y; };
	std::cout << add(1, 2) << std::endl;

	auto func = [] //参数列表和返回值省略
	{
		std::cout << "hello world" << std::endl;
	};

	return 0;
}

1.3.2 lambda的使用场景

在学习lambda之前，可调用对象只有函数指针和仿函数对象，但函数指针的类型定义起来比较麻烦，仿函数要定义一个类，相对来说也会比较麻烦。使用lambda去定义可调用对象，既简单又方便

看下面代码：

#include <vector>
#include <iostream>
#include <algorithm>
struct goods
{
	std::string _name; //商品名称
	double _price; //价格
	int _evaluate; //评估

	goods(const char* name,double price,int evaluate)
		:_name(name)
		,_price(price)
		,_evaluate(evaluate)
	{ }
};
struct comparePriceLess
{
	bool operator()(const goods& lg, const goods& rg)
	{
		return lg._price < rg._price;
	}
};
struct comparePriceGreater
{
	bool operator()(const goods& lg, const goods& rg)
	{
		return lg._price > rg._price;
	}
};
int main()
{
	std::vector<goods> list = { {"苹果",1.2,2},{"香蕉",1.5,3},{"葡萄",2.1,5} };
	//对商品按价格进行排序
	std::sort(list.begin(), list.end(), comparePriceLess());
	std::sort(list.begin(), list.end(), comparePriceGreater());
	return  0;
}

代码中可以看到，通过实现仿函数对象或函数指针来支持不同项的比较，相对来说还是比较麻烦的，要实现好多个我们所需要的仿函数，那么lambda就很好的解决了这一点

代码如下：

#include <vector>
#include <iostream>
#include <algorithm>
struct goods
{
	std::string _name; //商品名称
	double _price; //价格
	int _evaluate; //评估

	goods(const char* name,double price,int evaluate)
		:_name(name)
		,_price(price)
		,_evaluate(evaluate)
	{ }
};
int main()
{
	std::vector<goods> list = { {"苹果",1.2,2},{"香蕉",1.5,3},{"葡萄",2.1,5} };
	auto priceLess = [](const goods& lg, const goods& rg){return lg._price < rg._price; };
	//对价格进行排序
	std::sort(list.begin(), list.end(), priceLess);
	std::sort(list.begin(), list.end(), [](const goods& lg, const goods& rg){return lg._price > rg._price; });
	//对评估进行排序
	std::sort(list.begin(), list.end(), [](const goods& lg, const goods& rg){
		return lg._evaluate < rg._evaluate;
		});
	std::sort(list.begin(), list.end(), [](const goods& lg, const goods& rg) {
		return lg._evaluate > rg._evaluate;
		});
	return 0;
}

lambda本质上还是一个仿函数，该表达式其实就相当于一个“语法糖”

1.3.3 捕捉列表

lambda表达式中默认只能使用lambda函数体和参数中的变量，如果想使用外层作用域中的变量就需要进行捕捉

  • 捕捉的第一种方法：在捕捉列列表中显示的传值捕捉和引用捕捉捕捉的多个变量用逗号分割

伪代码例：

int a = 1,b = 2,c = 3;
auto add = [a,b,&c]{return a + b + c;}; 
//捕捉列表表示：a和b是值捕捉，&c是引用捕捉

注意：传引用捕捉的变量，若在lambda中被修改了，外部域的也会跟着修改

  • 捕捉的第二种方法：隐式捕捉，[=]，表示隐式捕捉；[&]，表示隐式引用捕捉，这样我们在lambda表达式中用了哪些变量，编译器就会自动捕捉

伪代码例：

int a = 1,b = 2,c = 3;
auto add = [=]{return a + b + c;}; 
auto func=[&]{a++;b--; return a+b+c;};

注意：lambda表达式中用了哪些变量，编译器就会去自动捕捉哪些变量，没有用到的就不会去捕捉

  • 捕捉的第三种方法：混合使用隐式捕捉和显示捕捉

伪代码例：

int a = 1,b = 2,c = 3,d = 4;
auto function1 = [=,&d]{d++;return a + d;}; //表示其他变量隐式捕捉，d显示引用捕捉
auto function2 = [&,a,b]{c++;return a + b;}; // 表示其他变量隐式引用捕捉，a和b是显示值捕捉

注意：当混合使用时，第一个元素必须是=或者&，并且第一个元素为&混合捕捉时，后面的捕捉必须为值捕捉，同理第一个元素为=混合捕捉时，后面的捕捉必须为引用捕捉

注意：局部的静态变量和全局变量不能捕捉，也不需要捕捉，直接就可以使用

1.3.4 mutable语法

lambda表达式中，传值捕捉本质上是一种拷贝，并且被const修饰所以不能被修改，但可以用mutable关键字来使值捕捉的变量在lambda表达式中被修改，但被修改的变量不会影响外部域的变量，因为它是一种拷贝

代码例：

int main()
{
	int a = 1, b = 2, c = 3;
	auto func = [=]()mutable {a++; b++; return a+b+c;};
	std::cout << func() << std::endl;
	std::cout << "a:" << a << " " << "b:" << b << " " << "c:" << c << std::endl;
	return 0;
}

在这里插入图片描述
可以看到外部域的变量并没有被修改

1.3.5 lambda的原理

lambda底层是仿函数对象，当写了一个lambda以后，编译器会自动生成一个对应的仿函数的类。仿函数的类型名是编译器按一定规则生成的，保证不同的lambda生成的类型名不同，lambda参数/返回类型/函数体就是仿函数operator的参数/返回类型/函数体，它的捕捉列表本质是生成的仿函数类的成员变量，也就是说捕捉列表的变量都是lambda类构造函数的实参，若是隐式捕捉，编译器要看使用哪些就传哪些变量.

muzi_liii
关注
蓝桥杯考试遇到的问题-＞无法使用c++11-＞Dev配置C++11环境
敖丙007的博客
04-08 5441
虽然蓝桥杯的宣传是支持c++11的,但是学校的机房一般是原配,不支持c++11,在考试中,考试的监考老师也无法及时解决此问题.
侯捷 C++标准11-14
qq_29230261的博客
10-16 2115
本篇记录学习《侯捷 C++标准11-14》 ---------------------------------------------------------------------------- 下面是语言的部分 ---------------------------------------------------------------------------- 一、演进、环境与资源 ...
C++11 - 无锁队列
fzzjoy的专栏
08-10 3803
无锁操作的本质依赖的原子操作，C++11提供了atomic的原子操作支持 CAS原子操作 CAS即Compare and Swap，是所有CPU指令都支持CAS的原子操作（X86中CMPXCHG汇编指令），用于实现实现各种无锁（lock free）数据结构。 CAS用于检查一个内存位置是否包含预期值，如果包含，则把新值复赋值到内存位置。成功返回true，失败返回false。示例代码如下：bool compare_and_swap ( int *memory_location, int expected_v
Microsoft Visual C++ 2015-2022 Redistributable (x64)
gitblog_09729的博客
09-06 8291
Microsoft Visual C++ 2015-2022 Redistributable (x64) MicrosoftVisualC2015-2022Redistributablex64-14.31.31103.7z项目地址:https://gitcode.com/open-source-toolkit/867a1 概述 本仓库提供了Microsoft Visual C++ 2015-20...
c++11 range-loop might detach Qt container (QStringList)避免方法
LYJ个人博客，记录技术、八卦、生活，分享各种心得，期待与朋友们一同进步
06-07 3936
字面描述是循环会分离此列表。 避免出现此警告用如下方法
c++ 11 for循环
一个老菜鸟的学习分享
03-06 9502
内容来自 深入应用C++11:代码优化与工程级应用 在 C++03/98 中，不同的容器和数组，遍历的方法不尽相同，写法不统一，也不够简洁，而 C++11 基于范围的 for 循环以统一、简洁的方式来遍历容器和数组，用起来更方便了。 C++11 for 循环的新用法 我们知道，在 C++ 中遍历一个容器的方法一般是这样的： #include <iostream> #include <vector> int main(void) { std::vector<int>
C++11 新特性 ---- long long 整形
呵呵哒!的博客
08-07 1702
同时，规定了每一种符号整型都有一种对应的无符号整型版本，且它们对应的无符号整型具有相同的存储空间大小。例如：signed int ----------（对应）----------》unsigned int。C++11 标准要求 long long 整型可以在不同平台上有不同的长度，但至少有64位。long long 整型有两种∶。C++11标准规定该类型至少占8字节，它占的字节数越多，对应能够存储的数值也就越大。整型的提升：若参数运算的数据或者传递的参数类型不匹配，整型间会发生隐式的转换。
C++11 range-based for loop
Dablelv 的博客专栏。
02-26 3934
很多编程语言都有range for语法功能，自C++11起，终于将这个重要功能加入C++标准中。range for语句，可以方便的遍历给定序列中的每个元素并对其执行某种操作。 1.基本语法 for(declaration:expression) statement 其中，declaration定义一个变量，该变量将被用于访问序列中的基础元素，每次迭代，declaration部分的...
让Dev C++支持C++11
2301_81973788的博客
02-16 3059
std=c++11。
g++/gcc 以c++11编译方法
weixin_38606457的博客
05-25 1944
gcc/g++以c++11编译 方法一: //在程序头加上预定义编译器命令 #pragma GCC diagnostic error "-std=c++11" //通过#pragma 指示 GCC编译器处理错误的方式以c++11标准; 方法二: //在编译指令中加-std=c++11 g++ test.cpp -o test -std=c++11 //在给一个模板类定义别名,用using时,g++会报错 error: expected unqualified-id before 'u.
gcc-toolset-11-gcc-c++-11.2.1-1.2.el8_5.aarch64.rpm
12-05
离线安装包，亲测可用
c++运行库2015-2019
05-22
- 2015至2019年间，C++标准库随着C++11、C++14和C++17新标准的引入，增加了许多新功能和改进，例如，右值引用、类型推断（auto）、lambda表达式、并发编程工具等。 3. **多线程支持**： - 自C++11起，C++运行库...
使用 C++ 和 ONNX Runtime 框架对 YOLOv11-CLS 图像分类模型进行部署（包含详细的完整的程序和数据）
10-14
主要内容：介绍了使用 C++ 结合 ONNX Runtime 来部署YOLOv11-CLS图像分类模型的过程。项目涵盖数据准备、代码示例（含详解）、模型加载以及从图片预处理到最终预测结果展示的整体流程。文中强调了系统的高性能表现，...
gcc-c++.zip
04-15
autogen-libopts-5.18-5.el7.x86 64.rpmgcc-c++-4.8.5-28.el7.x86 64.rpm keyutils-libs-devel-1.5.8-3.el7.x86 64.rpmkrb5-devel-1.15.1-18.el7.x86 64.rpm libcom err-1.42.9-11.el7.x86 64.rpmlibselinux-devel-...
cpp11-and-DX11-Tutorials:C++11 & DirectX11 教程
07-08
C++11 和 DX11 教程 适用于 Unity3D/XNA/Java 游戏开发人员 这些项目是视频教程的来源。 内容： 第 1 章 - C++ 基础 教程 1 - Hello World！ 教程 2 - 类型 教程 3 - 字符串操作 教程 4 - 函数 教程 5 - if 和循环...
C++ string小记
xmu_cjs的博客
05-16 153
【代码】C++ string小计。
【GESP】C++三级真题 luogu-B3956 [GESP202403 三级] 字母求和
最新发布
CoderCoding的博客
05-19 286
【GESP】C++三级真题 luogu-B3956 [GESP202403 三级] 字母求和 | OneCoder。GESP三级真题，字符串和一维数组相关题目，难度★★☆☆☆。GESP三级真题，字符串和一维数组相关题目，难度★★☆☆☆。
C语言-8.数组
wind_one1的博客
05-15 1386
本文介绍了C语言中数组的基本概念和使用方法。首先，通过计算用户输入数字的平均数为例，展示了如何利用数组存储数据并进行处理。接着，详细讲解了数组的定义、下标范围及注意事项，强调数组元素必须具有相同的数据类型，且数组大小在创建后不可改变。文章还介绍了数组的集成初始化、赋值和遍历操作，并指出数组作为函数参数时需要传入数组大小。此外，提供了统计数字出现次数和查找数组中特定元素的示例代码。最后，通过判断素数的例子，展示了如何优化算法以提高效率。
C 语言探秘：字符数组 vs. 字符串，那一抹神秘的 \0
Web安全工具库
05-16 759
本文深入探讨了C语言中字符数组与字符串的区别，重点在于字符串末尾的空字符\0。字符数组是纯字符的集合，而C语言字符串则是以\0结尾的特殊字符数组。\0标志着字符串的结束，对于标准库函数处理字符串至关重要。文章通过代码示例展示了\0在字符串处理中的作用，并提供了确保字符序列成为有效C语言字符串的建议，如使用字符串字面量初始化或手动添加\0。正确理解和使用\0是掌握C语言字符串处理的关键。
评论 16
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值