原文：https://www.cnblogs.com/guxuanqing/p/6707824.html

C++11：C++11包括大量的新特性：包括lambda表达式，类型推导关键字auto、decltype，和模板的大量改进。

新的关键字

auto

C++11中引入auto第一种作用是为了自动类型推导

auto的自动类型推导，用于从初始化表达式中推断出变量的数据类型。通过auto的自动类型推导，可以大大简化我们的编程工作

auto实际上实在编译时对变量进行了类型推导，所以不会对程序的运行效率造成不良影响

另外，似乎auto并不会影响编译速度，因为编译时本来也要右侧推导然后判断与左侧是否匹配。

1. auto a; // 错误，auto是通过初始化表达式进行类型推导，如果没有初始化表达式，就无法确定a的类型  
2. auto i = 1;  
3. auto d = 1.0;  
4. auto str = "Hello World";  
5. auto ch = 'A';  
6. auto func = less<int>();  
7. vector<int> iv;  
8. auto ite = iv.begin();  
9. auto p = new foo() // 对自定义类型进行类型推导 

auto不光有以上的应用，它在模板中也是大显身手，比如下例这个加工产品的例子中，如果不使用auto就必须声明Product这一模板参数：

1. template <typename Product, typename Creator>  
2. void processProduct(const Creator& creator) {  
3.     Product* val = creator.makeObject();  
4.     // do somthing with val  
5. }         
6.         . 

如果使用auto，则可以这样写：

1. template <typename Creator>  
2. void processProduct(const Creator& creator) {  
3.     auto val = creator.makeObject();  
4.     // do somthing with val  
5. } 

抛弃了麻烦的模板参数，整个代码变得更加正解了。

decltype

decltype实际上有点像auto的反函数，auto可以让你声明一个变量，而decltype则可以从一个变量或表达式中得到类型，有实例如下：

1. int x = 3;  
2. decltype(x) y = x; 

有人会问，decltype的实用之处在哪里呢，我们接着上边的例子继续说下去，如果上文中的加工产品的例子中我们想把产品作为返回值该怎么办呢？我们可以这样写：

1. template <typename Creator>  
2. auto processProduct(const Creator& creator) -> decltype(creator.makeObject()) {  
3.     auto val = creator.makeObject();  
4.     // do somthing with val  
5. } 

nullptr

nullptr是为了解决原来C++中NULL的二义性问题而引进的一种新的类型，因为NULL实际上代表的是0，

1. void F(int a){  
2.     cout<<a<<endl;  
3. }  
4.  
5. void F(int *p){  
6.     assert(p != NULL);  
7.  
8.     cout<< p <<endl;  
9. }  
10.  
11. int main(){  
12.  
13.     int *p = nullptr;  
14.     int *q = NULL;  
15.     bool equal = ( p == q ); // equal的值为true，说明p和q都是空指针  
16.     int a = nullptr; // 编译失败，nullptr不能转型为int  
17.     F(0); // 在C++98中编译失败，有二义性；在C++11中调用F（int）  
18.     F(nullptr);  
19.  
20.     return 0;  
21. } 

序列for循环

在C++中for循环可以使用类似java的简化的for循环，可以用于遍历数组，容器，string以及由begin和end函数定义的序列（即有Iterator），示例代码如下：

1. map<string, int> m{{"a", 1}, {"b", 2}, {"c", 3}};  
2. for (auto p : m){  
3.     cout<<p.first<<" : "<<p.second<<endl;  
4. } 

Lambda表达式

lambda表达式类似Javascript中的闭包，它可以用于创建并定义匿名的函数对象，以简化编程工作。Lambda的语法如下：

[函数对象参数]（操作符重载函数参数）->返回值类型{函数体}

1. vector<int> iv{5, 4, 3, 2, 1};  
2. int a = 2, b = 1;  
3.  
4. for_each(iv.begin(), iv.end(), [b](int &x){cout<<(x + b)<<endl;}); // (1)  
5.  
6. for_each(iv.begin(), iv.end(), [=](int &x){x *= (a + b);});     // (2)  
7.  
8. 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构造，构造一个包含两种不同类型的数据的容器。比如，如下代码：

1. auto p = make_pair(1, "C++ 11"); 

由于在C++11中引入了变长参数模板，所以发明了新的数据类型：tuple，tuple是一个N元组，可以传入1个， 2个甚至多个不同类型的数据

1. auto t1 = make_tuple(1, 2.0, "C++ 11");  
2. auto t2 = make_tuple(1, 2.0, "C++ 11", {1, 0, 2}); 

这样就避免了从前的pair中嵌套pair的丑陋做法，使得代码更加整洁

另一个经常见到的例子是Print函数，在C语言中printf可以传入多个参数，在C++11中，我们可以用变长参数模板实现更简洁的Print

1. template<typename head, typename... tail>  
2. void Print(Head head, typename... tail) {  
3.     cout<< head <<endl;  
4.     Print(tail...);  
5. } 

Print中可以传入多个不同种类的参数，如下：

1. Print(1, 1.0, "C++11"); 

更加优雅的初始化方法

在引入C++11之前，只有数组能使用初始化列表，其他容器想要使用初始化列表，只能用以下方法：

1. int arr[3] = {1, 2, 3}  
2. vector<int> v(arr, arr + 3); 

在C++11中，我们可以使用以下语法来进行替换：

1. int arr[3]{1, 2, 3};  
2. vector<int> iv{1, 2, 3};  
3. map<int, string>{{1, "a"}, {2, "b"}};  
4. 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的新特性提供了一些支持。

什么是C++11

C++11是曾经被叫做C++0x，是对目前C++语言的扩展和修正，C++11不仅包含核心语言的新机能，而且扩展了C++的标准程序库（STL），并入了大部分的C++ Technical Report 1（TR1）程序库(数学的特殊函数除外)。

C++11包括大量的新特性：包括lambda表达式，类型推导关键字auto、decltype，和模板的大量改进 等等。

本文将对C++11的以上新特性进行简单的讲解，以便大家能够快速了解到C++11对C++的易用性方面起到的巨大作用。

C++11 是第二个真正意义上的 C++ 标准，也是 C++ 的一次重大升级。C++11 增加了很多现代编程语言的特性，比如自动类型推导、智能指针、lambda 表达式等，这使得 C++ 看起来又酷又潮，一点也不输 Java 和 C#。

新的关键字

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，

以往我们使用NULL表示空指针。它实际上是个为0的int值

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++11 中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 ：英 [ˈlæmdə]

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"};

https://www.xuebuyuan.com/3265958.html

http://c.biancheng.net/cplus/11/

C++ 编译器支持情况表

下表为各个编译器对新的 C++ 功能特性的支持情况。这些功能特性包括 C++11 、 C++14 、 C++17 和之后接受的标准版本 (C++20/C++2a) ，还有几个技术规范的内容。

C++2a 功能特性

注意，此列表可能根据 C++2a 标准草案的演化而更改。

C++17 功能特性

C++14 功能特性

C++11 功能特性

引用

各编译器厂商的兼容性检查单文档（这些通常比以上表格更能反映最新的情况）

• GCC （更新于 2019-01 ）

• C++11 核心语言支持状况（ 4.8.1 起完成，除了无编译器实现的 n2670 ）
• C++14 核心语言支持状况（ 5.1 起完成）
• C++17 核心语言支持状况（ 7.1 起完成）
• C++20 核心语言支持状况
• C++11 库支持状况（ 5.1 起完成）
• C++14 库支持状况（ 5.1 起完成）
• C++17 库支持状况
• C++20 库支持状况
• 技术规范支持状况

• Clang++ （更新于 2017-09 ）

• C++11 核心语言支持状况（ 3.3 起完成）
• C++11 库支持状况（ 2012-07-29 起完成）
• C++14 核心语言支持状况（ 3.4 起完成）
• C++14 库支持状况（ 3.5 起完成）
• 技术规范支持状况
• C++17 核心语言支持状况（ 5.0 起完成）
• C++17 库支持状况
• C++20 核心语言支持状况
• C++20 库支持状况
• 核心语言缺陷报告状况

• Microsoft Visual Studio （更新于 2019-01 ）

• C++17 宣告： MSVC 遵从 C++ 标准（ 15.7 起完成）
• C++17 VS 2017 15.5 中的功能特性及 STL 修正
• C++17 VS 2017 15.3 中的功能特性和 STL 修正
• C++11/C++14/C++17 VS2017.3 中的核心语言和库状况
• C++11/C++14/C++17 核心语言支持状况

• VS2010 、 VS2012 、 VS2013 和 VS2015 中的 C++11/14/17 核心语言支持状况
• VS2013 vs. VS2015 CTP0
• VS2013 vs. VS2015 CTP1
• VS2013 vs. VS2015 CTP3 （包含路线图表格）
• VS2015 ("VS14") 预览
• VS2015 ("VS14") 发行候选 （ C++11 仍不完整，但出现 C++17 支持）
• VS2017

• C++11 和 C++14 库支持状况
• C++11/14/17 VS 2015 RTM 中的功能特性包含核心语言与标准库（包含技术规范）
• VS 2015 Update 2 标准库中的 C++14/17 功能特性 库对于当前 C++17 特性完整，有少量问题（一些缺陷报告、一些 constexpr 等）
• VS “15” Preview 5 中的 C++14/17 功能特性和 STL 修正包含详细的 C++17 状况表格

• Intel C++ （更新于 2017-11 ）

• C++11 核心语言支持状况（ 15.0 起完全支持）
• C++14 核心语言支持状况（ 17.0 起功能完整， N3664 是一项优化）
• C++17 核心语言支持状况（不完全支持）
• Intel 19.0 beta 的 C++17 特性
• Intel 不提供 C++ 标准库的实现，除了

• 并行 STL （ C++17 带执行策略支持的标准库算法的实现）

• Intel 与 GCC 的 libstdc++ 各版本间的兼容性

• EDG （更新于 2019-03 ）

• C++11 核心语言支持状况
• C++14 核心语言支持状况
• C++17 核心语言支持状况
• C++20 核心语言支持状况
• EDG 不提供 C++ 标准库的实现

• Oracle C++ (2017-07 更新)

• 版本号为编译器版本而非 Oracle Studio 版本
• C++11 核心语言支持状况

• 5.14 中已经加入所缺少的 C++11 支持（页面中有错误，仍然声称是 5.13）

• 5.14 中加入的 C++14 功能特性

• 5.15 中添加了完整 C++14 支持。

• Oracle 提供对标准库的四种不同实现：

• libCstd (RogueWave Standard Library version 2), 早于 C++98
• stlport4 (STLport Standard Library version 4.5.3), 早于 C++03
• stdcxx4 (Apache Standard Library version 4), 早于 C++11
• libstdc++ (GCC runtime library, 根据不同发布版本对 C++11 和 C++14 有所支持)

• IBM XL C++ （更新于 2018-05 ）

• IBM XL C++ for Linux

• 核心语言支持状况： 13.1.6 起 C++11 完整， 16.1.0 中部分 C++14
• IBM 在 Linux 上不提供 C++ 标准库实现（使用 GNU libstdc++ ）

• IBM XL C++ for AIX

• 核心语言支持状况： 13.1.3 中部分支持 C++11 。
• IBM 为 AIX 提供一个 Dinkumware 库的版本，带 C++ TR1 的完整支持，包括 <regex> ，但不支持 C++11

• HP aCC

• HP aC++ A.06.28 发行注记 (包括 C++11 核心语言功能特性)
• HP 提供了 RogueWave STL 2.0 对 C++98 标准库的实现的一个版本

• Digital Mars C++

• C++11 核心语言支持状况

• Embarcadero C++

• 语言功能特性遵从状况 (RAD Studio 10.1 Berlin) ，包括老式编译器与 Clang 增强编译器（基于 Clang 3.3 ）所支持的 C++11 功能特性
• 语言功能特性遵从状况 (RAD Studio 10.3 Rio) ，包括老式编译器所支持的 C++11 功能特性，和 Clang 增强编译器（基于 Clang 5.0 ）所支持的 C++11、 C++14 及 C++17 功能特性

• Cray （更新于 2018-01 ）

• [1] 声称 8.4 版支持除 alignas 外的全部 C++14
• Cray C 与 C++ 参考手册 (8.6) 对于版本 8.6 ，声称支持全部 C++14

• Portland Group (PGI) （更新于 2019-01 ）

• 2016 版发行注记 声称支持 C++14，但不支持“通用化的 constexpr 以及 constexpr 成员函数和隐含的 const, 变量模板，厘清内存分配（分配的合并）”
• 2018 版发行注记
• PGI 19.1 参考手册
• PGI 不提供 C++ 标准库的实现

• Texas Instruments （更新于 2018-05 ）

• cl430 版本 v18.1.0 声称 C++14 支持

• Analog Devices （更新于 2018-05 ）

• CrossCore Embedded Studio 2.8.0 for SHARC 声称 C++11 支持。

转载：https://zh.cppreference.com/w/cpp/compiler_support