什么是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++11新特性包括auto、decltype、constexpr、右值引用、move()函数、完美转发、移动构造、lambda匿名函数、for循环新格式、nullptr、shared_ptr、weak_ptr、unique_ptr、using定义别名、函数模板默认参数、tuple元组、非受限联合体、placement new、longlong int等。

二、正文

以下是我在学习过程中记录下来的笔记总结，实际代码较少，大多是知识点，比如相关的特性、定义、限制、作用和说明等等，放上一半的内容，剩下一半在文章底部的资源处，真的是个人用心精简的总结，谢谢支持和理解~~

• auto类型推导
  • 应用
    1. 定义迭代器
    2. 泛型编程
  • 限制
    1. auto声明的变量必须赋值初始化，因此auto也不能够在函数参数中进行使用，也不能作用于非静态的类成员变量，因为类成员在声明的时候并不能赋值
    2. auto关键字不能定义数组
    3. auto不能用作模板参数
  • 性质
    1. auto 仅仅是一个占位符，在编译器期间它会被真正的类型所替代
    2. 推导不可具有二义性
    3. 当类型不为引用时auto的推导结果不保留表达式的const属性，反之则保留
  • 简介：C++11之前，auto 表示变量是自动存储的，这也是编译器的默认规则，所以写不写都一样；C++11之后，auto 用于自动类型推到，关键字以后，编译器会在编译期间自动推导出变量的类型。

• decltype(declare type)　　基础用法：decltype(exp)  var;
  • 返回值类型后置
    1. 为了解决函数返回值类型依赖于参数而导致难以确定返回值类型的问题
    2. auto decltype结合使用
  • 与auto区别
    1. auto根据赋值推导，decltype根据表达式推导变量类型
    2. auto要求变量必须初始化，而decltype不用
  • 推导规则
    1. 如果是一个普通变量或类成员访问表达式，推导类型和exp一致
    2. 如果是函数调用，和返回值一致
    3. 如果是左值或者括号包围的表达式，推导类型为exp的引用
  • 实际应用
    1. 用于类成员的类型推导
• 对函数模板默认模板参数的支持（之前只支持类模板默认模板参数）
• tuple元组
  1. 特点：实例化的对象可以存储任意数量任意类型的数据
• 列表初始化（统一初始化格式）
• lambda匿名函数
  1. 格式：

     [外部变量方位方式说明符] (参数) mutable noexcept/throw() -> 返回值类型

     {

             函数体;

     };

  2. 说明
     1. [外部变量方式方位说明符]：[]用于声明当前是lambda表达式，方括号内部注明当前函数体中可以使用哪些外部变量
     2. (参数)：和普通函数一样用于传递参数，如果不接收参数可以省略
     3. mutable：以值传递引入的外部变量默认为常量，若要修改它们，则需要使用mutable关键字，可省略
     4. noexcept/throw()：默认情况下lambda函数可以抛出任何类型的异常，如果noexcept则不会抛出任何异常，如果throw()可以指定抛出异常的类型，可以省略
     5. ->返回值类型：指定lambda匿名函数的返回值类型。如果函数体内只有一个return或者该函数返回void，则可以省略
     6. 函数体：既可以使用值传递的参数，还可以使用指定的外部变量和全局范围内的所有全局变量，外部变量会受到以值传递还是引用传递方式引入的影响，而全局变量不会，lambda表达式内可以使用并直接修改全局变量的值
  3. 应用示例
     1. 最简单的匿名函数：[]{};
     2. 排序数组sort(num.begin(), num.end(), [=](int x, int y) -> x > y);
     3. 给匿名函数起名字auto display = []{};
• using定义别名
  1. 作用：给一种类型或者函数模板重新命名，在typedef之上多了模板重命名的功能
• 非受限联合体(union)
  1. C++联合体中允许非POD类型
  2. POD类型
     1. 不包含虚函数和虚基类
     2. 非静态成员必须声明为public
     3. 没有用户自定义的析构、构造、拷贝函数
  3. placement new
     1. new关键字的一种进阶用法，既可以在堆上生成对象也可以在栈上生成对象
     2. 语法：new(address) ClassConstruct(...)；adress表示已有的内存地址，可以是某个变量的引用，ClassConstruct表示调用类的构造函数

最后放出全部内容的资源链接，多谢~~ 

 C++11新特性实用总结word版本-C++文档类资源-CSDN下载主要是C++11新特性的定义，特性，使用限制等，关于具体如何使用新特性的代码不多，大部分是知识内容，更多下载资源、学习资料请访问CSDN下载频道.https://download.csdn.net/download/weixin_44178960/85018835