一、目录
 
一、目录…
 二、新的语言特性…
 1、 泛型的 Lambda 函数…
 2、 Lambda 捕获表达式…
 3、 函数返回类型推导…
 4、 另一种类型推断…
 5、 放松的 constexpr 限制…
 6、 变量模板…
 7、 聚合体成员初始化…
 8、 二进制字面值…
 9、 数字分位符…
 三、新的标准库特性…
 1、 共享的互斥体和锁…
 2、 元函数的别名…
 3、 关联容器中的异构查找…
 4、 标准自定义字面值…
 5、 通过类型寻址多元组…
 6、较小的标准库特性…
 四、 已被移除或是不包含在 C++14 标准的特性…
 1、 关于数组的扩展…
 2、 Optional 值…
 3、 Concepts Lite…
 
二、新的语言特性
 
1 、泛型的 Lambda 函数
 
在 C++11 中，lambda 函数的形式参数需要被声明为具体的类型。C++14 放宽了这一要求，允许 lambda 函数的形式参数声明中使用类型说明符 auto。
 
auto lambda = [](auto x, auto y) {return x + y;}
 
泛型 lambda 函数遵循模板参数推导的规则。以上代码的作用与下面的代码相同：
 
struct unnamed_lambda
{
template<typename T, typename U>
auto operator()(T x, U y) const {return x + y;}
};

auto lambda = unnamed_lambda();
 
2 、Lambda 捕获表达式
 
C++11 的 lambda 函数通过值拷贝（by copy）或引用（by reference）捕获（capture）已在外层作用域声明的变量。这意味着 lambda 的值成员不可以是 move-only 的类型。C++14允许被捕获的成员用任意的表达式初始化。这既允许了 capture by value-move，也允许了任意声明 lambda 的成员，而不需要外层作用域有一个具有相应名字的变量。
 
这是通过使用一个初始化表达式完成的：
 
auto lambda = [value = 1] {return value;}
 
lambda 函数 lambda 的返回值是 1，说明 value 被初始化为 1。被声明的捕获变量的类型会根据初始化表达式推断，推断方式与用 auto 声明变量相同。
 
使用标准函数 std::move 可以使之被用以通过 move 捕获：
 
auto ptr = std::make_unique<int>(10); //See below for std::make_unique
auto lambda = [ptr = std::move(ptr)] {return *ptr;}
 
声明 ptr = std::move(ptr)使用了两次 ptr。第一次使用声明了一个新的变量，但在捕获部分，这个变量还不在作用域内。所以第二个 ptr 表示之前在 lambda 之外声明的变量。
 
3 、函数返回类型推导
 
C++11 允许 lambda 函数根据 return 语句的表达式类型推断返回类型。C++14 为一般的函数也提供了这个能力。C++14 还拓展了原有的规则，使得函数体并不是{return expression;}形式的函数也可以使用返回类型推导。
 
为了启用返回类型推导，函数声明必须将 auto 作为返回类型，但没有 C++11 的后置返回类型说明符：
 
auto DeduceReturnType(); //返回类型由编译器推断
 
如果函数实现中含有多个 return 语句，这些表达式必须可以推断为相同的类型。[9]
 
使用返回类型推导的函数可以前向声明，但在定义之前不可以使用。它们的定义在使用它们的翻译单元（translation unit）之中必须是可用的。
 
这样的函数中可以存在递归，但递归调用必须在函数定义中的至少一个 return 语句之后：
 
auto Correct(int i) 
{
	if (i == 1)
		return i; // 返回类型被推断为 int
	else
		return Correct(i-1)+i; // 正确，可以调用
}

auto Wrong(int i)
{
	if(i != 1)
		return Wrong(i-1)+i; // 不能调用，之前没有 return 语句
	else
		return i; // 返回类型被推断为 int
}
 
4 、另一种类型推断
 
C++11 中有两种推断类型的方式。auto 根据给出的表达式产生具有合适类型的变量。decltype 可以计算给出的表达式的类型。但是，decltype 和 auto 推断类型的方式是不同的。
 
特别地，auto 总是推断出非引用类型，就好像使用了 std::remove_reference 一样，而 auto&&总是推断出引用类型。然而 decltype 可以根据表达式的值类别（value category）和表达式的性质推断出引用或非引用类型：
 
int i;
int&& f();
auto x3a = i; // x3a 的类型是 int
decltype(i) x3d = i; // x3d 的类型是 int
auto x4a = (i); // x4a 的类型是 int
decltype((i)) x4d = (i); // x4d 的类型是 int&
auto x5a = f(); // x5a 的类型是 int
decltype(f()) x5d = f(); // x5d 的类型是 int&&
 
C++14 增加了 decltype(auto)的语法。这允许不必显式指定作为 decltype 参数的表达式，而使用 decltype 对于给定表达式的推断规则。
 
decltype(auto)的语法也可以用于返回类型推导，只需用 decltype(auto)代替 auto。
 
5 、放松的 constexpr 限制
 
C++11 引入了 constexpr 函数的概念，这样的函数可以在编译期执行。它们的返回值可以用于期望常量表达式的场合（如模板的非类型参数）。然而 C++11 要求 constexpr 函数只含有一个将被返回的表达式（也可以还含有 static_assert 声明等其它语句，但允许的语句类型很少）。
 
C++14 将放松这些限制。声明为 constexpr 的函数将可以含有以下内容：
  任何声明，除了：static 或 thread_local 变量、没有初始化的变量声明。
  条件分支语句 if 和 switch。goto 是不允许的。
  所有的循环语句，包括基于范围的 for 循环。
  表达式可以改变一个对象的值，只需该对象的生命期在常量表达式函数内开始。包括对有 constexpr 声明的任何非 const 非静态成员函数的调用。
 
调用非 constexpr 函数仍然是受限的。所以如果使用基于范围的 for 循环，begin 和 end的重载形式必须自身被声明为 constexpr。值得注意的是，std::initializer_list 在本地和全局都具有 constexpr 声明的 begin/end 函数。
 
此外，C++11 指出，所有被声明为 constexpr 的非静态成员函数也隐含声明为 const（即函数不能修改*this 的值）。这点已经被删除，非静态成员函数可以为非 const。然而，只有当对象的生命期在常量表达式求值中开始，非const的constexpr成员函数才可以修改类成员。
 
6 、变量模板
 
在 C++之前的版本中，模板可以是函数模板或类模板（C++11 引入了类型别名模板）。C++14 现在也可以创建变量模板。包括特化在内，通常的模板的规则都适用于变量模板的声明和定义。
 
7 、聚合体成员初始化
 
C++11 新增 member initializer，这是一个表达式，被应用到类作用域的成员上，如果构造函数没有初始化这个成员。聚合体的定义被改为明确排除任何含有 member initializer 的类，因此，他们不允许使用聚合初始化。C++14 将放松这一限制，这种类型也允许聚合初始化。如果花括号初始化列表不提供该参数的值，member initializer 会初始化它。
 
8 、二进制字面值
 
C++14 的数字可以用二进制形式指定。其格式使用前缀 0b 或 0B。这样的语法也被 Java、Python、Perl 和 D 语言使用。
 
9 、数字分位符
 
C++14 引入单引号（’）作为数字分位符号，使得数值型的字面量可以具有更好的可读性。Ada、D 语言、Java、Perl、Ruby 等程序设计语言使用下划线（_）作为数字分位符号，C++之所以不和它们保持一致，是因为下划线已被用在用户自定义的字面量的语法中。
 
auto integer_literal = 100'0000;
auto floating_point_literal = 1.797'693'134'862'315'7E+308;
auto binary_literal = 0b0100'1100'0110;
auto silly_example = 1'0'0'000'00;
 
三、新的标准库特性
 
1 、共享的互斥体和锁
 
C++14 增加了一类共享的互斥体和相应的共享锁。起初选择的名字是 std::shared_mutex，但由于后来增加了与 std::timed_mutex 相似的特性，std::shared_timed_mutex 成为了更适合的名字。
 
2 、元函数的别名
 
C++11 定义了一组元函数，用于查询一个给定类型是否具有某种特征，或者转换给定类型的某种特征，从而得到另一个类型。后一种元函数通过成员类型 type 来返回转换后的类型，当它们用在模板中时，必须使用 typename 关键字，这会增加代码的长度。
 
template <class T>
type_object<
typename std::remove_cv<
typename std::remove_reference<T>::type
>::type
>get_type_object(T&);
 
利用类型别名模板，C++14 提供了更便捷的写法。其命名规则是：如果标准库的某个类模板（假设为 std::some_class）只含有唯一的成员，即成员类型 type，那么标准库提供std::some_class_t作为 typename std::some_class::type 的别名。在 C++14，拥有类型别名的元函数包括：remove_const、remove_volatile、remove_cv、add_const、add_volatile、add_cv、remove_reference、add_lvalue_reference、add_rvalue_reference、make_signed、make_unsigned、remove_extent、remove_all_extents、remove_pointer、add_pointer、aligned_storage、aligned_union、decay、enable_if、conditional、common_type、underlying_type、result_of、tuple_element。
 
template <class T>
type_object<std::remove_cv_t<std::remove_reference_t<T>>>
get_type_object(T&);
 
3 、关联容器中的异构查找
 
C++标准库定义了四个关联容器类。set 和 multiset 允许用户根据一个值在容器中查找对应的的同类型的值。map 和 multimap 容器允许用户指定键（key）和值（value）的类型，根据键进行查找并返回对应的值。然而，查找只能接受指定类型的参数，在 map 和 multimap中是键的类型，而在 set 和 multiset 容器中就是值本身的类型。C++14 允许通过其他类型进行查找，只需要这个类型和实际的键类型之间可以进行比较操作。[17]这允许 std::setstd::string使用 const char*，或任何可以通过 operator< 与 std::string比较的类型作为查找的参数。为保证向后兼容性，这种异构查找只在提供给关联容器的比较器允许的情况下有效。标
 准库的泛型比较器，如 std::less<>与 std::greater<>允许异构查找。
 
4 、标准自定义字面值
 
C++11 增加了自定义字面量（user-defined literals）的特性，使用户能够定义新的字面量后缀，但标准库并没有对这一特性加以利用。C++14 标准库定义了以下字面量后缀：
  “s”，用于创建各种 std::basic_string 类型。
  “h”、“min”、“s”、“ms”、“us”、“ns”，用于创建相应的 std::chrono::duration 时间间隔。
 
using namespace std::literals;
std::string str = "hello world"s;
std::chrono::seconds dur = 60s;
 
 两个"s"互不干扰，因为表示字符串的只能对字符串字面量操作，而表示秒的只针对数
 字。
 
5 、通过类型寻址多元组
 
C++11 引入的 std::tuple 类型允许不同类型的值的聚合体用编译期整型常数索引。C++14还允许使用类型代替常数索引，从多元组中获取对象。若多元组含有多于一个这个类型的对象，将会产生一个编译错误：
 
tuple<string, string, int> t("foo", "bar", 7);
int i = get<int>(t); // i == 7
int j = get<2>(t); // Same as before: j == 7
string s = get<string>(t); //Compiler error due to ambiguity
 
6 、较小的标准库特性
 
std::make_unique 可以像 std::make_shared 一样使用，用于产生 std::unique_ptr 对象。
 std::is_final，用于识别一个 class 类型是否禁止被继承。
 std::integral_constant 增加了一个返回常量值的 operator()。
 全局 std::begin/std::end 函数之外，增加了 std::cbegin/std::cend 函数，它们总是返回常量迭代器（constant iterators）。
 
四、已被移除或是不包含在 C++14 标准的特性
 
1 、关于数组的扩展
 
在 C++11 和之前的标准中，在堆栈上分配的数组被限制为拥有一个固定的、编译期确定的长度。这一扩展允许在堆栈上分配的一个数组的最后一维具有运行期确定的长度。运行期确定长度的数组不可以作为对象的一部分，也不可以具有全局存储期，他们只能被声明为局部变量。运行期确定长度的数组也可以使用 C++11 的基于范围的 for 循环。
 
同时还将添加 std::dynarray 类型，它拥有与 std::vector 和 std::array 相似的接口。代表一个固定长度的数组，其大小在运行期构造对象时确定。std::dynarray 类被明显地设计为当它被放置在栈上时（直接放置在栈上，或作为另一个栈对象的成员），可以使用栈内存而是堆内存。
 
2 、Optional 值
 
类似于 C#中的可空类型，optional 类型可能含有或不含有一个值。这一类型基于 Boost的 boost::optional 类，而添加了 C++11 和 C++14 中的新特性，诸如移动和 in-place 构造。它不允许用在引用类型上。这个类被专门的设计为一个 literal type（如果模板参数本身是一个literal type），因此，它在必要的情况下含有 constexpr 构造函数。
 
3 、Concepts Lite
 
被 C++11 拒绝后，Concepts 受到彻底的修改。Concepts Lite 是 Concepts 的一个部分，仅包含类型约束，而不含 concept_map 和 axiom。它将在一个单独的 Technical Specification中发展，并有可能加入 C++17。

 
文章目录
 
引言
C++14
函数返回值推导
lambda参数auto
decltype(auto)
Lambda捕获部分中使用表达式
变量模板与别名模板
更为宽松的constexper
[[deprecated]]标记
二进制字面量与整形字面量分隔符
integer_sequence 类
std::make_unique
std::shared_timed_mutex与std::shared_lock
std::exchange
标准自定义字面量
  
 

 
引言
 
打算花两天时间写三篇文章，把C++14,17,20已有的新特性说一说，为什么突然心血来潮想干这个事情呢，原因是在上课某个划水的课的时候玩手机看到了GCC最新的10.2.0版本在今年七月二十三号的时候已经发布了，在这个版本中已经支持了协程，并且在9月4日C++ 20的国际标准草案投票结束，而且获得了全票通过，这实在是让人心血澎湃啊！果断升级到最新版本，却猛然发现已经把C++11以上版本的特性忘的差不多了，恰好明天国庆，遂今天给自己放放假，就不动脑子了，边听歌边复习下这些特性吧。
 
《C++17特性一览》
 
 
C++14
 
总的的来说C++14并不是一个大更新，甚至可以说是一个很小的更新，因为没有什么让人眼前一亮的特性，基本是一些小玩意儿。
 
函数返回值推导
 
auto func_one(int i) {
    return i;
}

template<typename T> auto func_one(T t){    // 模板中也可以这样玩
    return t;
}

/*
auto func(bool flag) {
    if (flag) return 1;
    else return 2.3; // 在出现多个类型分支的时候没办法推导
}

auto func() {
    return {1, 2, 3}; // 初始化列表也没办法被推导
}
*/

cout << func_one(2) << " " << func_one<double>(5.5) << endl;
输出：
2 5.5
 
lambda参数auto
 
auto func_two = [] (auto a) { return a;};

cout << func_two("hello world!") << " " << func_two("1024") << endl;

输出：
hello world! 1024
 
decltype(auto)
 
C++11中有两种推断类型的方式。auto根据给出的表达式产生具有合适类型的变量。decltype可以计算给出的表达式的类型。但是，decltype和auto推断类型的方式是不同的。特别地，auto总是推断出非引用类型，就好像使用了std::remove_reference一样，而auto&&总是推断出引用类型。然而decltype可以根据表达式的值类别（value category）和表达式的性质推断出引用或非引用类型
 
这篇文章把这个问题描述的非常全面《C++14尝鲜：decltype 和 decltype(auto)》
 
Lambda捕获部分中使用表达式
 
这意味着我们可以在捕获子句（capture clause）中，也就是[ ]中增加并初始化新的变量，该变量不需要在lambda表达式所处的闭包域中存在
 
auto ptr = std::make_unique<int>(10); //See below for std::make_unique
auto lambda = [value = std::move(ptr)] {return *value;}
 
变量模板与别名模板
 
template<class T>   // 变量模板 最典型的用法就是pi，在以前只能用一个没有参数的模板函数来返回
constexpr T pi = T(3.1415926535897932385L);

template<typename T, typename U>
struct str_three{
    T t;
    U u;
};

// C++11引入类型别名的原因是因为无法在typedef语句的基础上直接构建别名模板
// 别名模板可以使声明一个只带一个模板参数T的类模板，使其等价于模板参数T
// 为int类型的str_three模板
template<typename U>
using var_three = str_three<int, U>;

----------------------------------------

cout << pi<int> << " " << pi<double> << endl;
var_three<int> temp_three;
temp_three.t = 10;
temp_three.u = 20;
cout << temp_three.t << " " << temp_three.u << endl;

输出：
3 3.14159
10 20 
 
下面这篇文章讲的非常详细：《C++14尝鲜：别名模板和变量模板》
 
更为宽松的constexper
 
/**
 * C++11: 1. 函数的返回类型以及所有形参的类型都得是字面值类型
 *        2. 函数体中只能由一个return语句
 * C++14: 1. 可以使用局部变量和循环
 *        2. 可以使用多个return
 */
constexpr int factorial_four(int n) { // C++14 和 C++11均可
    return n <= 1 ? 1 : (n * factorial_four(n - 1));
}

// 多返回值与局部变量
constexpr int factorial(int n) { // C++11中不可，C++14中可以
    if(n < 0) return 0;
    int ret = 0;
    // int items[20]; 这样定义是不对的
    for (int i = 0; i < n; ++i) {
        ret += i;
    }
    return ret;
}
输出：
10
120
 
[[deprecated]]标记
 
// 编译时被产生警告，用户提示开发者该标记修饰的内容将来可能会被丢弃，尽量不要使用
// 可以修饰类、变、函数等
struct [[deprecated]] var_five {
    int item;
};

[[deprecated]] constexpr int func_five(){
    return 200;
}
 
二进制字面量与整形字面量分隔符
 
 int a = 0b0001'0011'1010;
 double b = 3.14'1234'1234'1234;
 // 这种字符串的语法糖别忘了C++11的原生字符串
 
integer_sequence 类
 
《integer_sequence 类》
 《模板展开及integer_sequence妙用》
 
它的作用为：类模板 std::integer_sequence 表示一个编译时的整数序列。在用作函数模板的实参时，能推导参数包 Ints 并将它用于包展开。
 
但是这个东西我不太清楚有什么实际的用处，可能在元编程中有一些奇奇怪怪的用处吧。现在我能看到的一个用处就是把一个容器的每一项在编译期当做一个函数的参数，这个作用在C++17中可以被std::apply代替。
 
std::make_unique
 
 std::unique_ptr<int> ptr = std::make_unique<int>(5);
 cout << *ptr << endl;
 输出：
 5
 
这没什么说的，不清楚为什么C++11中没有。
 
std::shared_timed_mutex与std::shared_lock
 
不清楚为什么14有了shared_timed_mutex，shared_mutex17才有。
 
把这东西当做一个带超时的读写锁就可以了，至于shared_lock，读的时候我们当然不能使用unique_ptr啦。
 
下面的代码是从别人那里直接拿的，可以理解为一个简单的读写锁。
 
struct ThreadSafe {
    mutable std::shared_timed_mutex mutex_;
    int value_;

    ThreadSafe() {
        value_ = 0;
    }

    int get() const {
        std::shared_lock<std::shared_timed_mutex> loc(mutex_);
        return value_;
    }

    void increase() {
        std::unique_lock<std::shared_timed_mutex> lock(mutex_);
        value_ += 1;
    }
};
 
其中与超时有关的借口可以直接查看官网传送门
 
std::exchange
 
它与std::swap有什么区别呢？我们来看一个简单的样例：
 
 std::vector<int> items;
 std::exchange(items, {1,0,2,4});
 for (int x : items) {
     cout << x << " ";
 }
 输出：
 1 0 2 4
 
看起来好像与swap一样，我们来看看exchange的实现：
 
  template <typename _Tp, typename _Up = _Tp>
    inline _Tp
    exchange(_Tp& __obj, _Up&& __new_val)
    { return std::__exchange(__obj, std::forward<_Up>(__new_val)); }

  template <typename _Tp, typename _Up = _Tp>
    inline _Tp
    __exchange(_Tp& __obj, _Up&& __new_val)
    {
      _Tp __old_val = std::move(__obj);
      __obj = std::forward<_Up>(__new_val);
      return __old_val;
    }
 
简单来说就是这样：
 
template<class T, class U = T>
constexpr T exchange(T& obj, U&& new_value) {
    T old_value = std::move(obj);
    obj = std::forward<U>(new_value);
    return old_value;
}
 
也就是把后面参数的值全部通过move转移到第一个参数上，不过第一个参数的值并不进行转移，源码让人想起了引用折叠和完美转发，忘记的朋友可以去复习复习。
 
标准自定义字面量
 
“s”，用于创建各种std::basic_string类型。
“h”、“min”、“s”、“ms”、“us”、“ns”，用于创建相应的std::chrono::duration时间间隔。
“if”、“i”、"il"用于创建相应的 std::complex、 std::complex 和 std::complex 复数类型。
 
auto str = "hello world"s; // 自动推导为 std::string
auto dur = 60s;            // 自动推导为 chrono::seconds
auto z   = 1i;             // 自动推导为 complex<double>
 
参考可能看起来有些乱，因为这些是看这些特性时的全部参考，包括后面要写的C++17，这里附上了参考，后面就不写啦
 
参考：
 
文档《C++ Standards Support in GCC》
资源《Index of /gnu/gcc/gcc-10.2.0》
博客《C++14新特性的所有知识点全在这儿啦！》
博客《C++17新特性》
博客《C++20 新增特性》
博客《Linux升级gcc到最新版本–gcc-9.1.0》
维基《https://baike.tw.lvfukeji.com/baike-C%2B%2B14》

原文：https://www.cnblogs.com/guxuanqing/p/6707824.html
 
C++11：C++11包括大量的新特性：包括lambda表达式，类型推导关键字auto、decltype，和模板的大量改进。
 
新的关键字
 
auto
 
C++11中引入auto第一种作用是为了自动类型推导
 
auto的自动类型推导，用于从初始化表达式中推断出变量的数据类型。通过auto的自动类型推导，可以大大简化我们的编程工作
 
auto实际上实在编译时对变量进行了类型推导，所以不会对程序的运行效率造成不良影响
 
另外，似乎auto并不会影响编译速度，因为编译时本来也要右侧推导然后判断与左侧是否匹配。
 
auto a; // 错误，auto是通过初始化表达式进行类型推导，如果没有初始化表达式，就无法确定a的类型  
auto i = 1;  
auto d = 1.0;  
auto str = "Hello World";  
auto ch = 'A';  
auto func = less<int>();  
vector<int> iv;  
auto ite = iv.begin();  
auto p = new foo() // 对自定义类型进行类型推导 
auto不光有以上的应用，它在模板中也是大显身手，比如下例这个加工产品的例子中，如果不使用auto就必须声明Product这一模板参数：
 
template <typename Product, typename Creator>  
void processProduct(const Creator& creator) {  
    Product* val = creator.makeObject();  
    // do somthing with val  
}         
        . 
如果使用auto，则可以这样写：
 
template <typename Creator>  
void processProduct(const Creator& creator) {  
    auto val = creator.makeObject();  
    // do somthing with val  
} 
抛弃了麻烦的模板参数，整个代码变得更加正解了。
 
decltype
 
decltype实际上有点像auto的反函数，auto可以让你声明一个变量，而decltype则可以从一个变量或表达式中得到类型，有实例如下：
 
int x = 3;  
decltype(x) y = x; 
有人会问，decltype的实用之处在哪里呢，我们接着上边的例子继续说下去，如果上文中的加工产品的例子中我们想把产品作为返回值该怎么办呢？我们可以这样写：
 
template <typename Creator>  
auto processProduct(const Creator& creator) -> decltype(creator.makeObject()) {  
    auto val = creator.makeObject();  
    // do somthing with val  
} 
nullptr
 
nullptr是为了解决原来C++中NULL的二义性问题而引进的一种新的类型，因为NULL实际上代表的是0，
 
void F(int a){  
    cout<<a<<endl;  
}  
 
void F(int *p){  
    assert(p != NULL);  
 
    cout<< p <<endl;  
}  
 
int main(){  
 
    int *p = nullptr;  
    int *q = NULL;  
    bool equal = ( p == q ); // equal的值为true，说明p和q都是空指针  
    int a = nullptr; // 编译失败，nullptr不能转型为int  
    F(0); // 在C++98中编译失败，有二义性；在C++11中调用F（int）  
    F(nullptr);  
 
    return 0;  
} 
序列for循环
 
在C++中for循环可以使用类似java的简化的for循环，可以用于遍历数组，容器，string以及由begin和end函数定义的序列（即有Iterator），示例代码如下：
 
map<string, int> m{{"a", 1}, {"b", 2}, {"c", 3}};  
for (auto p : m){  
    cout<<p.first<<" : "<<p.second<<endl;  
} 
Lambda表达式
 
lambda表达式类似Javascript中的闭包，它可以用于创建并定义匿名的函数对象，以简化编程工作。Lambda的语法如下：
 
[函数对象参数]（操作符重载函数参数）->返回值类型{函数体}
 
vector<int> iv{5, 4, 3, 2, 1};  
int a = 2, b = 1;  
 
for_each(iv.begin(), iv.end(), [b](int &x){cout<<(x + b)<<endl;}); // (1)  
 
for_each(iv.begin(), iv.end(), [=](int &x){x *= (a + b);});     // (2)  
 
for_each(iv.begin(), iv.end(), [=](int &x)->int{return x * (a + b);});// (3) 
[]内的参数指的是Lambda表达式可以取得的全局变量。(1)函数中的b就是指函数可以得到在Lambda表达式外的全局变量，如果在[]中传入=的话，即是可以取得所有的外部变量，如（2）和（3）Lambda表达式
()内的参数是每次调用函数时传入的参数。
->后加上的是Lambda表达式返回值的类型，如（3）中返回了一个int类型的变量
变长参数的模板
 
我们在C++中都用过pair，pair可以使用make_pair构造，构造一个包含两种不同类型的数据的容器。比如，如下代码：
 
auto p = make_pair(1, "C++ 11"); 
由于在C++11中引入了变长参数模板，所以发明了新的数据类型：tuple，tuple是一个N元组，可以传入1个， 2个甚至多个不同类型的数据
 
auto t1 = make_tuple(1, 2.0, "C++ 11");  
auto t2 = make_tuple(1, 2.0, "C++ 11", {1, 0, 2}); 
这样就避免了从前的pair中嵌套pair的丑陋做法，使得代码更加整洁
 
另一个经常见到的例子是Print函数，在C语言中printf可以传入多个参数，在C++11中，我们可以用变长参数模板实现更简洁的Print
 
template<typename head, typename... tail>  
void Print(Head head, typename... tail) {  
    cout<< head <<endl;  
    Print(tail...);  
} 
Print中可以传入多个不同种类的参数，如下：
 
Print(1, 1.0, "C++11"); 
更加优雅的初始化方法
 
在引入C++11之前，只有数组能使用初始化列表，其他容器想要使用初始化列表，只能用以下方法：
 
int arr[3] = {1, 2, 3}  
vector<int> v(arr, arr + 3); 
在C++11中，我们可以使用以下语法来进行替换：
 
int arr[3]{1, 2, 3};  
vector<int> iv{1, 2, 3};  
map<int, string>{{1, "a"}, {2, "b"}};  
string str{"Hello World"}; 
然后呢…
 
如果你想了解更多C++11令人兴奋的新特性，我会向你推荐这两个博客：
 
胡健的C++11系列博文
 
ToWrting的C++11系列博文
 
C++11的编译器支持列表
 
原文链接：http://my.oschina.net/wangxuanyihaha/blog/183151
 
C++14：C++14的主要特性可以分为三个领域：Lambda函数、constexpr和类型推导。
 
Lambda函数
 
C++14的泛型Lambda使编写如下语句成为可能：
 
auto lambda = [](auto x, auto y) {return x + y;};
 
而另一方面，C++11要求Lambda参数使用具体的类型声明，比如：
 
auto lambda = [](int x, int y) {return x + y;};
 
此外，新标准中的std::move函数可用于捕获Lambda表达式中的变量，这是通过移动对象而非复制或引用对象实现的：
 
std::unique_ptr ptr(new int(10));
auto lambda = [value = std::move(ptr)] {return *value;};
 
constexpr
 
在C++11中，使用constexpr声明的函数可以在编译时执行，生成一个值，用在需要常量表达式的地方，比如作为初始化模板的整形参数。C++11的constexpr函数只能包含一个表达式，C++14放松了这些限制，支持诸如if 和switch等条件语句，支持循环，其中包括基于区间（range）的for 循环。
 
类型推导
 
C++11仅支持Lambda函数的类型推导，C++14对其加以扩展，支持所有函数的返回类型推导：
 
auto DeducedReturnTypeFunction();
 
因为C++14是强类型语言，有些限制需要考虑：
 
如果一个函数的实现中有多个返回语句，这些语句一定要推导出同样的类型。
返回类型推导可以用在前向声明中，但是在使用它们之前，翻译单元中必须能够得到函数定义。
返回类型推导可以用在递归函数中，但是递归调用必须以至少一个返回语句作为先导，以便编译器推导出返回类型。
C++14带来的另一个类型推导方面的改进是decltype(auto)语法，它支持使用与auto同样的机制计算给定表达式的类型。auto和 decltype在C++11中就已经出现了，但是它们在推导类型时使用了不同的机制，这可能会产生不同的结果。
 
C++14中的其他改变包括可以声明变量模板，支持使用0b或0B前缀来声明二进制字面常量。InfoQ已经介绍过C++14中可能破坏C++11程序的其他小型修改。
 
主流C++编译器对新语言特性的支持正在有条不紊地开发：Clang“完全实现了当前草案的所有内容”；GCC和Visual Studio也对C++14的新特性提供了一些支持。

 
在github上有人总结了：
 C++新特性总结