C++11特性—1

精选原创

麋璐 2023-06-11 21:10:12 博主文章分类：C++ ©著作权

文章标签 decltype 智能指针 lambda 文章分类 C/C++ 后端开发

©著作权归作者所有：来自51CTO博客作者麋璐的原创作品，请联系作者获取转载授权，否则将追究法律责任

C++11是C++标准的一个新版本，它增加了很多C++没有的功能，相较性能而言，极大程度上提高了C++效率和易用；对于程序员而言，C++11更好的应用于系统开发和库开发，语法更加泛华和简单化，更加稳定和安全。因此C++11功能更加强大，而且能提升程序员的开发效率。

以下我们来了解下C++11基于C++进行的主要功能升级都有那些吧！！

变量类型推导

为什么需要类型推导？

在定义变量时，必须先给出变量的实际类型，编译器才允许定义，这对于内置类型来说，是非常简单的，例如：

int main()
{
	int a = 32670;
	int b = 32670;
	int c = a + b;
  return 0;
}

此时，代码是绝对没有问题的。但是，如果我们给出的接收变量的范围有限，或者a和b为浮点型，但是我们却使用整形c接收呢？？

int main()
{
	short a = 32670;
	short b = 32670;
	short c = a + b;
  
  double a1=12.34;
  double b1=12.45;
  int c1=a1+b1;
  return 0;
}

C++11特性—1_智能指针

此时就会出现两种情况：

相加元素越界，得不到我们想要的答案
数据丢失，导致结果不够精确

这都是我们不想看到的，更有甚者，我们在使用迭代器遍历容器时，也会出现迭代器太过复杂的情况，如下：

int main()
{
	std::map<std::string, std::string> m{ { "apple", "苹果" }, { "banana", "香蕉" } };
	// 使用迭代器遍历容器, 迭代器类型太繁琐，一不小心可能导致报错，非常的麻烦！！
	std::map<std::string, std::string>::iterator it = m.begin();
	while (it != m.end())
	{
		cout << it->first << " " << it->second << endl;
		++it;
	}
	return 0;
}

因此，C++11中就提供了一种可以推导表达式类型的关键字——auto关键字，auto关键字可以根据变量初始化表达式类型推断变量的实际类型，这样我们在定义变量时也就可以不在考虑太多类型推导了，遍历map也就变成这样了：

int main()
{
	std::map<std::string, std::string> m{ { "apple", "苹果" }, { "banana", "香蕉" } };
	auto it = m.begin();//只需要一个auto==std::map<std::string, std::string>::iterator
	while (it != m.end())
	{
		cout << it->first << " " << it->second << endl;
		++it;
	}
	return 0;
}

这样，即排除了人为造成的变量类型定义错位的问题，又能节约大量时间，代码看上去也更加简洁。

decltype类型推导

auto关键字使用的前提是：必须要对auto声明的类型进行初始化，否则编译器无法推导出auto的实际类型。但有时候可能需要根据表达式运行完成之后结果的类型进行推导，因为编译期间，代码不会运行，此时auto也就无能为力。

int Add(auto left, auto right)//此时调用就会出现问题
{
	return left + right;
}

C++11特性—1_decltype_02

简单来说，就是auto不能作为函数的参数，因为函数是在编译时期，编译器会扫描源代码中的所有函数定义，并在编译过程中将其转换为可执行的代码。由于没有具体值得传递，此时的auto未能推导出参数的类型。

因此，我们给出了decltype关键字，来先推导定义变量的类型，然后再根据类型接收我们需要的值。

int main()
{
	int a = 10, b = 20;
	decltype(a + b) c;//这里就是先推导出c的类型，然后再进行赋值操作
	cout << typeid(c).name() << endl;
}

并且，对于函数的推演也是可以的，对于没有参数的推演，就会返回整个函数的定义；而如果是带参数列表的推演，返回的就是函数的返回值类型(函数并未运行)。

C++11特性—1_lambda_03

智能指针

本章大家可以看我的博客：智能指针和智能指针补其中有非常完整的C++中三种智能指针的介绍。

lambda表达式

为什么需要lambda

在C++中，如果我们对一个数据集合中的元素进行排序就需要用到sort函数：

int main()
{
	vector<int> arr{ 4, 1, 8, 5, 3, 7, 0, 9, 2, 6 };
	sort(arr.begin(), arr.end(), less<int>());//升序
	sort(arr.begin(), arr.end(),greater<int>());//降序
	return 0;
}

当如果我们需要对自定义类型进行排序时，每有两种类型需要比较，用户就需要一个函数来定义排序的规则，例如：

struct Person
{
	string _name;
	int _price;
};
struct Compare//定义的排序规则
{
	bool operator()(const Person& gl, const Person& gr)
	{
		return gl._price <= gr._price;
	}
};
int main()
{
	Person gds[] = { { "苹果", 2 }, { "相交", 3 }, { "橙子", 24 }, { "菠萝", 1.5 } };
	sort(gds, gds + sizeof(gds) / sizeof(gds[0]), Compare());
	return 0;
}

看看，为了一个排序，我们被迫写了7行代码，如果是更大的项目呢，那可就不是7行代码就能解决的了，每次为了实现一个Compare算法，都要重新去写一个类，如果每次比较的逻辑不一样，还要去实现多个类，特别是相同类的命名，这些都给编程者带来了极大的不便。因此，在C11语法中出现了Lambda表达式。

Lambda表达式

我们先来看个示例：

int main()
{
 Goods gds[] = { { "苹果", 2.1 }, { "相交", 3 }, { "橙子", 2.2 }, {"菠萝", 1.5} };
 sort(gds, gds + sizeof(gds) / sizeof(gds[0]), [](const Goods& l, const Goods& r)
                                               ->bool
                                                {
                                                    return l._price < r._price;
                                                });
 return 0;
}

上述示例中我们不难看出，Lambda表达式其实就是一个匿名函数。

lambda表达式书写格式：[capture-list] (parameters) mutable -> return-type { statement }，下面我来给大家一一说明这些参数的含义

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

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

接下开为大家解析以下常见的Lambda函数：

int main()
{
	//最简单的lambda表达式, 该lambda表达式没有任何意义
	[]{};

	//省略参数列表和返回值类型，返回值类型由编译器推导为int
	int a = 3, b = 4;
	[=]{return a + 3; };//[]里的=会捕获前面所有变量，但只是传值捕获，不会改变变量本身

	//省略了返回值类型，无返回值类型
	auto fun1 = [&](int c){b = a + c; };//&，表示捕获为引用形式，函数内值发生改变，变量也会发生改变
	fun1(10);
	cout << a << " " << b << endl;

	//各部分都很完善的lambda函数
	auto fun2 = [=, &b](int c)->int{return b += a + c; };//这里表示a为传值，b为传引用
	cout << fun2(10) << endl;

	//复制捕捉x
	int x = 10;
	auto add_x = [x](int a) mutable { x *= 2; return a + x; };//这里表示直接捕获x，a和b也会被默认捕获
	cout << add_x(10) << endl;
	return 0;
}

注意：Lambda函数无法直接调用或者直接输出，如果我们需要直接调用，需要使用auto变量将其赋值。

捕捉列表描述了上下文中那些数据可以被lambda使用，以及使用的方式传值还是传引用，下面我们给出常见的捕获列表说明(var表示变量)：