C++14 常用新特性总结

1. 返回值类型推导（Return type deduction）

为什么返回类型推导对于C++程序来说是锦上添花的。首先，有时候你必须返回一个非常复杂的类型，比如在对标准库容器进行搜索的时候返回一个迭代器。auto返回类型使得函数更加易读，易写。其次，这个原因可能不是那么明显，使用auto返回类型能够增强你的重构能力。举个例子，考虑下面的代码：

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

struct record {
std::string name;
int id;
};

auto find_id(const std::vector<record> &people,
const std::string &name)
{
auto match_name = [&name](const record& r) -> bool {
return r.name == name;
};
auto ii = find_if(people.begin(), people.end(), match_name );
if (ii == people.end())
return -1;
else
return ii->id;
}

int main()
{
std::vector<record> roster = { {"mark",1},
{"bill",2},
{"ted",3}};
std::cout << find_id(roster,"bill") << "\n";
std::cout << find_id(roster,"ron") << "\n";
}

在这个例子中，使find_id返回auto比返回int并没有使我节省多少脑力。但是考虑一下，如果我决定重构record结构体，会发生生么。这次我不在record对象中使用一个整型来唯一标记一个人了，而是使用一个新的GUID类型：

struct record {
	std::string name;
	GUID id;
};

对record对象所做的这个改变会导致一系列的连锁反应，比如函数的返回类型会发生变化。但是如果我对函数返回值使用自动类型推导，编译器会默默的应对这些变化。任何在大型工程上进行开发的C++程序员都会熟悉这个问题。对单一数据结构的修改会导致无休止的对原代码的迭代，对变量，参数以及返回类型的修改。auto的广泛使用能够消减很大一部分这样的工作。

使用auto作为返回值的立竿见影的效果是reality of it's doppelganger, decltype(auto)，还有有了类型推导的规则。现在你可以使用它来自动获取类型信息了，如下面的代码片段：

template<typename Container>
	struct finder {
	static decltype(Container::find) finder1 = Container::find;
	static decltype(auto) finder2 = Container::find;
};

2. 泛型lambdas

另外一个auto悄悄潜伏的地方是在lambda参数的定义中。使用auto类型声明定义lambda参数同创建模板函数基本相当。lambda会基于参数推导类型来进行特定的实例化。

这对创建可在不同上下文中重用的lambdas来说是很方便的。在下面的简单例子中，我创建了一个lambdas用做标准库函数的谓词（predicate）。在C++11的世界里，我分别为整型加法，字符串加法显示的实例化了一个lambda。

有了泛型lambda，我能用其定义单一的lambda。虽然它的语法不包括关键字template，这仍然是对C++泛型编程的进一步扩展：

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

int main()
{
	std::vector<int> ivec = { 1, 2, 3, 4};
	std::vector<std::string> svec = { "red",
	"green",
	"blue" };
	auto adder = [](auto op1, auto op2){ return op1 + op2; };
	std::cout << "int result : "
	<< std::accumulate(ivec.begin(),
	ivec.end(),
	0,
	adder )
	<< "\n";
	std::cout << "string result : "
	<< std::accumulate(svec.begin(),
	svec.end(),
	std::string(""),
	adder )
	<< "\n";
	return 0;
}

产生如下结果：

int result : 10
string result : redgreenblue

即使你对匿名inline lambdas进行实例化，正如如前面讨论的，泛型参数仍然是有用的。当你的数据结构发生了变化或者APIs中的函数被修改了，对泛型lambdas进行调整时只需要重新编译就可以了，不需要重新实现：

std::cout << "string result : "
<< std::accumulate(svec.begin(),
svec.end(),
std::string(""),
[](auto op1,auto op2){ return op1+op2; } )
<< "\n";

3. 被初始化的lambdas捕获(Initialized lambda captures)

在C++11中我们必须开始适应lambda捕获特化（lambda capture specification）的概念。这种声明会在创建闭包（closure）的时候对编译器进行引导：lambda定义了一个函数的实例，还有定义在lambda作用域之外的绑定在函数上的变量。

在早期的推导返回类型的例子中，我实现了捕获单个变量名字的一个lambda定义，用做谓词中搜索字符串的源：

auto match_name = [&name](const record& r) -> bool {
	return r.name == name;
};
	auto ii = find_if(people.begin(), people.end(), match_name );

 这种特殊的捕获使lambda获取了按引用访问变量的权限。捕获也能按值来执行，在两种情况中，变量的使用方式都会符合C++的直觉。按值捕获意味着lambda在本地变量的拷贝上进行操作，按引用捕获意味着lambda在外围作用域的变量本身进行操作。

这些都很好，但也会有伴随而来的一些局限性。我想委员会感觉需要处理的一件事情是使用move-only语义来初始化捕获变量。

这意味着什么？如果我们认为lambda即将成为参数的接收器，我们想使用move语义捕获外部变量。举个例子，考虑如何使lambda接收一个move-only unique_ptr参数。第一个尝试是按值捕获，失败了：

std::unique_ptr<int> p(new int);
*p = 11;
auto y = [p]() { std::cout << "inside: " << *p << "\n";};

这会生成一个编译错误因为unique_ptr没有拷贝构造函数——它所想的就是禁止拷贝。

将其改为按引用捕获就能编译通过，但是没有达到预期效果：也就是通过将值move到本地的拷贝来接收参数。最后你可以通过先创建本地变量然后在捕获的引用上调用std::move（）来完成，但是效率不高。

通过对捕获语句语法进行修改可以修复这个问题。现在我们不是只声明一个捕获变量，我们也能对其初始化。看下面的例子：auto y = [&r = x, x = x+1]()->int {...}

auto y = [&r = x, x = x+1]()->int {...}

 上面的代码捕获了x的拷贝，同时为x增加了1。这个例子很容易理解，但是我不确定它是否为接收move-only变量捕获了这种新语法的值。使用这个新语法的例子如下：

#include <memory>
#include <iostream>

int main()
{
	std::unique_ptr<int> p(new int);
	int x = 5;
	*p = 11;
	auto y = [p=std::move(p)]() { std::cout << "inside: " << *p << "\n";};
	y();
	std::cout << "outside: " << *p << "\n";
	return 0;
}

在这个例子中，捕获的值p用move语义来初始化，在没有声明本地变量的情况下有效的接收了指针：
inside: 11
Segmentation fault (core dumped)

这个令人讨厌的结果正是你想要的——在p被捕获并且move到lambda中后，代码对p进行了解引用。

4. [[弃用的]][[deprecated]]属性

 

初次看到deprecated 属性是在java中，我承认有点嫉妒。对大多数程序员来说代码腐烂（rot）是一个巨大的问题。（曾经鼓励删除代码？但我从来没有这么做过）。这个新属性提供了攻克这个问题的系统级别的方法。

用起来很简单，将标签【[[deprecated]]放在声明之前就可以了，声明可以为类，变量，函数或其他东西。结果像下面这个样子：

[[deprecated]] flaky {};

 

当你的程序使用了一个deprecated实体，原本需要编译器做出反应，现在留给了代码实现者。很清楚大多数人希望能够看到某种警告，也能随手把这种warning关掉。举个例子，clang3.4在实例化一个deprecated类的时候会发出以下警告：
dep.cpp:14:3: warning: 'flaky' is deprecated [-Wdeprecated-declarations]
flaky f;
^
dep.cpp:3:1: note: 'flaky' declared here
flaky {
^

C++的属性标记语法看上去有点不熟悉。在属性列表中，[[deprecated]]被放在关键字（如class 或者enum）之后，实体名字之前。
这个标记有另外一种形式，它包含了一个信息参数。由开发人员决定如何写这个信息。clang3.4忽略了这个信息。

看下面的代码片段：

class
[[deprecated]] flaky {
};

[[deprecated("Consider using something other than cranky")]]
int cranky()
{
return 0;
}

int main()
{
flaky f;
return cranky();
}

5. 二进制数字和数字分隔符

有两个新功能不是惊天动地的，但他们确实代表了很好的句法结构的改善。这样的很小的改变改善了代码可读性，进一步减少了bug数量。C++ 程序员现在可以创建一个二进制数字，向已经包含十进制，十六进制以及很少使用的八进制的标准中又添加了一员。二进制数字使用前缀0b后面紧接数字。在美国和英国，我们使用逗号来作为数字分隔符，如：$1,000,000。这种写法真正方便了读者，使得我们的大脑处理很长的数字时更加容易。因为同样的原因C++标准委员会添加了数字分隔符。它们不影响数值，只是通过分块让数字的读写更加容易。

数字分隔符使用什么字符？在C++中基本上每个标点符号都被特定的特性使用了，因此没有很明显的选择。最后的选择是使用单引号字符，使得C++的百万数表示如下：1'000'000.00。记住分隔符对数值没有任何影响，因此百万数也可表示如下：1'0'00'0'00.00。
下面的例子使用了两个新特性：

#include <iostream>

int main()
{
int val = 0b11110000;
std::cout << "Output mask: "
<< 0b1000'0001'1000'0000
<< "\n";
std::cout << "Proposed salary: $"
<< 300'000.00
<< "\n";
return 0;
}

结果也是你所意料的：
Output mask: 33152
Proposed salary: $300000

6. 剩余特性

c++的其他新特性无需多述。变量模板在变量上对模板的扩展。总会使用到的例子是变量pi<T>的一个实现。当实现为double的时候，变量会返回3.14,当实现为int时，它可能返回3,当实现为string时，可能返回“3.14”或者"pi"，这是个很棒的特性，以前是在<limits>中实现的。变量模板的语法和语义和类模板是基本相同的——你无需额外的学习就能使用它们。对constexpr函数的限制放松了，例如，可以有多个返回值，可以在内部使用case和if语句，可以用循环以及其它。这就对能在编译器做的事进行了扩展，为模板的引入插上了翅膀。其他小的特性包括为内存分配指定大小（sized deallocations）和一些语法的整理（tidying）。

相关博客：

C++11 常用新特性总结

原文链接