咱们聊聊 C++11 新特性。这个标准在 2011 年正式定稿，距离上一个正式标准 C++98 已经过去了整整十三年。这十三年里，C++ 程序员们一边用着老语法，一边盼着语言层面能有实质性的变化。C++11 发布之后，整个社区的写码方式几乎被重塑了一遍：内存管理从裸指针转向智能指针，手写循环变成范围 for，函数对象被 lambda 替代，单线程思维被标准线程库撬开。如果你做过几年 C++ 开发，回头看自己的老代码，大概率会感叹“这居然也是 C++”。
这篇文章不只列特性，我想借实际开发视角把 C++11 的核心改动拆开讲：为什么要设计成这个样子、迁移时会踩到哪些坑、每个特性在什么场景下才值得用。适合两类人看：一类是刚接触现代 C++ 的开发者，另一类是手里有 C++98 老项目、正在纠结要不要升级的人。读完你至少能回答一个问题：C++11 到底改变了什么，以及我该怎么把它用起来。
1. 背景与设计思路：C++11 到底解决什么问题
1.1 十三年等来的转折点
C++98 时代的 C++ 能力很强，但用起来很“拧巴”。手写内存管理容易漏，STL 容器虽然强大，迭代器类型写起来能把人绕晕，函数对象为了一个排序逻辑就得单独写个仿函数类。当年还有一个老大难：标准库没有线程支持，想做并发只能调平台 API，Windows 下一套、Linux 下一套，代码没法移。
Boost 社区当时做了大量实验，很多后来进标准的东西最早都在 Boost 里验证过。C++11 相当于把社区沉淀多年的经验收编进标准。它最核心的设计目标有三条：保持零开销抽象的性能哲学、让日常代码写起来更简单、让资源管理更安全。听上去有点矛盾——又要性能又要安全又要省事，但 C++11 确实做得不错，它靠的是编译器帮你做事，而不是运行时替你兜底。
1.2 设计目标上的取舍逻辑
理解 C++11，要先接受它的底层逻辑：不引入昂贵的运行时机制，而是靠编译期推导、类型系统和语法糖来解决问题。举个例子，auto 并不是让类型“变动态”，而是让编译器在编译期把类型推断出来，运行时和手写类型完全一样，零开销。智能指针本质是栈上对象管理堆上对象的生命周期，析构函数自动释放资源，这就是 RAII 思想的一以贯之。
这跟其他语言走的路完全不同。有些语言选择引入垃圾回收机制，牺牲确定的析构时机；C++11 坚持“资源随作用域释放”，智能指针只是把这种思想从理论变成库实现。所以你在用 shared_ptr 时，它内部会有引用计数，这个计数是原子操作，比裸指针多了一点开销，但换来的是异常安全——只要栈对象还在，堆对象就不会没人管。在设计上，它允许你为安全付一点微小代价，但绝不允许为语法糖付出整体性能。
聊 C++11 新特性时，我建议你抱着一个念头：每学一个新特性，先问自己它替换了哪种老写法，带来了什么收益。比如 nullptr 替换的是 NULL 带来的类型混淆，范围 for 替换的是手写迭代器循环，移动语义替换的是“拷贝后销毁临时对象”的浪费。这样学完不会变成“背特性清单”，而是真正能用到代码里。
2. 重构日常编码的核心语法：auto、nullptr、范围 for、初始化列表
2.1 auto 的类型推导与细节陷阱
先看 auto。它的出现让 C++ 代码从“类型冗长”里解放出来。以前写迭代器是这样的：
std::map<std::string, std::vector<int>>::const_iterator it = m.find("key");现在可以写成：
auto it = m.find("key");声明即所得，编译器自动推断。很多人觉得 auto 是“偷懒神器”，但真正的价值在于组合复杂类型：lambda 的类型是匿名且唯一的，不靠 auto 根本写不出来；模板编程里，依赖类型推导的地方更是离不开它。
但 auto 有个经常坑人的特性：它会丢弃引用和顶层 const。意思是说，const Widget& w = getWidget();用auto w2 = w;得到的并不是引用，而是值拷贝。想要保持原样，必须显式写成auto& w2 = w;或const auto& w2 = w;。很多新手在这里翻车，改了引用类型还以为是编译器的问题，其实是对“推导规则”理解不到位。
我在实际项目里的经验是：读数据用const auto&，要修改元素用auto&，只关心值本身可以用auto拷贝。总之，别总让 auto 背锅，它只是忠实地按规则推导，关键是写的人要表达清楚意图。
2.2 nullptr 与 NULL 的恩怨
C++98 时代我们用 NULL 表示空指针，但它本质上是一个整数 0。这就引出经典问题：如果有两个重载函数void f(int); void f(char*);，调用f(NULL)会匹配到f(int)，因为 NULL 被规约成 0，能当作整数用。这显然不是写代码的人想要的效果。
C++11 引入了nullptr，它有独立的类型std::nullptr_t，可以安全地转换为任何指针类型，但不会转换成整数。这样重载决议就能准确匹配指针版本。还有一个细微好处：模板推导时，NULL 会被推导成 int，而 nullptr 会推导成std::nullptr_t，很多模板代码因此正确工作。
我的建议很明确：新代码一律用 nullptr；老代码迁移时，凡是代表空指针的 NULL 都批量替换为 nullptr。唯一需要留意的是某些第三方库的头文件里还写着 NULL，但那是库作者的问题，我们在自己的代码层面对齐标准即可。
2.3 范围 for 循环：写起来爽，改坏容器就惨
范围 for 是我用得最频繁的特性之一。以前遍历 vector 是这样的：
for (std::vector<int>::iterator it = v.begin(); it != v.end(); ++it) { // ... }现在直接：
for (const auto& x : v) { std::cout << x << std::endl; }范围 for 的本质是编译器帮你展开成 begin()/end() 迭代器循环，所以任何支持 begin/end 的类型都能用：数组可以，自定义容器只要提供了 begin()/end() 成员函数或全局重载也可以。只读遍历写const auto&，要修改元素写auto&，知道元素的拷贝很廉价时才按值取。
这里必须强调一个大坑：范围 for 遍历过程中，不要对容器本身做结构性修改，比如 push_back、erase、insert。因为迭代器会失效，轻则读到脏数据，重则直接崩溃。我踩过一次：遍历一个 vector 时想把符合条件的元素删掉，结果第一次 erase 之后迭代器就失效了，程序随机崩溃。正确做法是先把要删的下标收集起来，再遍历下标删除；或者用 C++11 之后的标准算法配合 erase-remove 惯用法。
2.4 列表初始化：大括号带来的严谨性
C++11 支持用花括号统一初始化对象的各个成员和容器元素：
std::vector<int> v = {1, 2, 3, 4, 5}; std::map<std::string, int> m = {{"a", 1}, {"b", 2}}; int arr[] = {1, 2, 3};这份能力由std::initializer_list<T>提供。它的核心价值是“窄化转换保护”——如果你写int x{3.14};，编译器会报错，因为浮点数到整数的转换被判定为可能损失精度。老式写法int x = 3.14;是默认截断的，悄无声息丢数据。这一点非常有用，尤其在做数值计算初始化时能挡住低级错误。
但列表初始化有个歧义陷阱：std::vector<int> v{10, 2};表示有两个元素 10 和 2；而std::vector<int> v(10, 2);表示 10 个值为 2 的元素。花括号优先匹配 initializer_list，所以如果你真想创建 10 个 2，用圆括号；如果想用两个元素，用花括号。这个坑在面试里经常出现，在真实项目里也遇到过几次，写了花括号结果元素个数完全不对。
3. lambda 表达式与函数对象的现代化改造
3.1 从仿函数到匿名函数
C++98 里想给 sort 传一个自定义比较规则，最常见的做法是写一个仿函数类：
struct Compare { bool operator()(const Item& a, const Item& b) const { return a.price < b.price; } }; std::sort(items.begin(), items.end(), Compare());虽然能工作，但为了一处临时的比较逻辑，你得写一个类，把逻辑和调用点隔离开，读代码时还得来回跳。lambda 表达式改变了这一切——它允许你在需要可调用对象的地方直接定义一个匿名函数：
std::sort(items.begin(), items.end(), [](const Item& a, const Item& b) { return a.price < b.price; });lambda 在语言层面解决了“局部逻辑局部表达”的问题，想给回调传参、想在容器内部做条件过滤，都能当场写一个。它的本质是一个匿名的函数对象，编译器会生成一个独一无二的类，所以这也是为什么前面说 auto 对 lambda 很重要——你没法写出 lambda 的类型名，只能靠 auto 承接。
3.2 捕获列表的捕获规则
lambda 语法中，[]是捕获列表，用来决定 lambda 内部能访问外部哪些变量：
[x]按值捕获 x，外部 x 的后续修改不影响 lambda 内部副本。[&x]按引用捕获 x，lambda 内部使用的是同一对象。[=]按值捕获所有可见变量。[&]按引用捕获所有可见变量。
使用上有个经典陷阱：如果你按引用捕获了一个栈上局部变量，把这个 lambda 存起来（比如放到 std::function 里），等那个局部变量已经出了作用域再调用 lambda，就变成了悬垂引用。轻则读到垃圾值，重则直接段错误。正确做法是，被延后调用的 lambda 尽量按值捕获；真要按引用捕获，必须保证调用时对象还活着。线程回调里尤其要注意这一点。
3.3 mutable、返回值与实用写法
lambda 默认不能修改按值捕获的变量，因为生成的函数对象 operator() 是 const 的。如果你想在 lambda 内部修改按值捕获的变量副本，但在外部保持不可见，就要加 mutable 关键字。大多数场景用不上，但做状态累积时它就很有用。
lambda 的返回值可以自动推导，也可以显式指定。单条语句时自动推导很好用，复杂逻辑建议显式写返回类型：
auto f = [](int x) -> double { if (x > 0) return x * 1.5; else return 0.0; };我在项目里最常用的组合是“lambda + 标准算法”：配合 sort、find_if、for_each、transform，把以前散落各处的循环逻辑压缩到一处表达。这不仅是“省几行代码”，更重要的是可读性——算法名字说明了意图，lambda 说明了细节，两者一分开，代码非常清爽。
4. 移动语义与右值引用：理解 C++11 的真正门槛
4.1 右值引用：改写“拷贝”这门生意
如果只挑一个最能代表 C++11 变化深度的特性，我会选移动语义。在 C++98 里，一个对象传给函数、放进容器、作为返回值，通常伴随着拷贝。拷贝意味着分配新内存、复制数据，哪怕源对象马上要销毁，也没办法“省掉”这一步。
右值引用解决的就是这个问题。一个T&&只能绑定到右值，也就是“临时对象”或者被显式转换成右值的对象。它代表一个语义：这个对象的资源不再被需要，新对象可以直接把它的资源“偷”过来。移动构造函数做的事就是夺取源对象的指针或句柄，然后把源对象置为可析构的空状态。这就像搬家：旧房子马上要拆了，直接把家具搬到新家，而不是重新买一套再安置。
有个典型的例子是std::vector的返回值。以前返回一个大的临时 vector，会经历多次拷贝；有了移动语义，内部缓冲区直接转移，几乎零成本。这也是为什么现代 C++ 里“按值返回容器”不再让人心疼。
4.2 写一个移动构造函数
我以一个简单的类为例说明如何写移动构造：
class StringHolder { public: StringHolder() : data_(new char[1]) { data_[0] = '\0'; } StringHolder(const char* s) : data_(nullptr) { if (s) { size_t len = strlen(s) + 1; data_ = new char[len]; memcpy(data_, s, len); } } // 拷贝构造 StringHolder(const StringHolder& other) { size_t len = strlen(other.data_) + 1; data_ = new char[len]; memcpy(data_, other.data_, len); } // 移动构造 StringHolder(StringHolder&& other) noexcept : data_(other.data_) { other.data_ = nullptr; } ~StringHolder() { delete[] data_; } private: char* data_; };移动构造函数中，我把other.data_直接拿过来，然后把other.data_置空，这样析构 other 时不会释放我们已经接管的缓冲区。这个“置空”步骤千万不能省，否则两个对象析构时会 double free。
还有一点很关键：移动构造函数要标记 noexcept。因为标准容器（比如 vector）扩容时需要把旧元素搬移到新内存，如果移动操作可能抛异常，容器为了强异常保证会退回使用拷贝构造。也就是说，你的类明明写了移动构造，但因为没标 noexcept，vector 扩容时实际还是走的昂贵拷贝。这是新手最容易忽略的细节，直接关系到移动语义有没有真正生效。
4.3 std::move 与完美转发
std::move 本身不移动任何东西，它只是一个类型转换工具，把左值无条件转换为右值引用，让后续代码可以匹配移动构造或移动赋值。真正移动的其实是构造函数或赋值操作符的实现。
std::string a = "hello"; std::string b = std::move(a); // 调用 std::string 的移动构造 // 此时 a 一般变为空，不要再依赖 a 的内容使用 std::move 后的对象，其值处于“合法但未指定”的状态。合法意味着可以安全析构、可以重新赋值；未指定意味着你不能假设它还是原来的值。这是很多 bug 的源头：move 完还继续读原对象，读到空字符串还算运气好，读到悬挂指针就麻烦多了。
std::forward 是另一个工具，用于完美转发：在模板函数中，按参数原本的左右值属性转发给下一个函数。它的核心价值在于保留“值类别”，这个在写泛型库时极其重要，普通业务代码用得相对少。你只需要知道，需要“把参数原样往下传”的场景就用 forward 而不是简单传值。
4.4 三条与五条规则：特殊成员函数的联动
移动语义出现后，C++ 的特殊成员函数从 3 个变成 5 个：默认构造、析构、拷贝构造、拷贝赋值、移动构造、移动赋值，严格算是 6 个。它们之间存在联动关系：如果你声明了析构函数，编译器就不会自动生成移动构造；如果你声明了拷贝赋值，移动赋值也不会自动生成。这个联动是为了防止你对资源管理做出自定义动作后，编译器还按默认方式“猜”你的意图，从而产生危险行为。
我建议的工程规范是：一个类如果需要自定义析构、拷贝、移动中的任何一个，就把其余特殊成员函数都显式补全（或用 =default / =delete）。别让编译器“半自动”生成，否则容易出现“我写了拷贝构造，但移动构造没了，所有移动退化成拷贝”这种隐蔽性能问题。这里用到的就是 C++11 提供的=default和=delete语法：
class Demo { public: Demo() = default; ~Demo() = default; Demo(const Demo&) = delete; // 禁止拷贝 Demo& operator=(const Demo&) = delete; // 禁止赋值 Demo(Demo&&) = default; // 移动默认 Demo& operator=(Demo&&) = default; };在 C++11 新特性里，这批语法糖不像 lambda 那么显眼，但它是保证特殊成员函数行为正确的基石。
5. 并发支持与资源管理：写多线程不再依赖平台 API
5.1 std::thread 与统一线程模型
C++98 标准库没有线程概念，多线程代码都是“平台相关的”。有的公司封装一层自己的线程库，有的直接用平台 API，可移植性很差。C++11 标准引入了std::thread，终于让“跨平台多线程”成为语言标准的一部分。
基本用法很直接：
std::thread t([] { std::cout << "hello from thread" << std::endl; }); t.join();join() 会等待线程执行完毕；不 join 的话，如果线程还活着而 std::thread 对象析构，会触发 std::terminate。所以要么保证线程执行完，要么明确调用 detach() 让线程与对象分离。detach 是个危险操作，线程里只要引用了调用者作用域内的栈变量，而调用者函数退出时变量销毁，线程再访问就出问题。我见过一堆线上偶现崩溃，原因都是 detach 后线程还在访问栈对象，排查了很久才发现是生命周期问题。
还有一个经验：线程函数如果有多个参数，最好把所有参数显式封装进一个结构体，按值传入线程函数内部。这样虽然有点笨，但能彻底切断线程与调用者栈之间的引用关系，大大减少悬垂引用。
5.2 互斥锁与 RAII 封装
多线程共享数据需要互斥锁。C++11 提供 std::mutex、std::lock_guard、std::unique_lock。你不要裸调 lock()/unlock()，一旦中间抛异常，unlock 就不会执行，其他线程永久阻塞。正确做法是用 RAII 包装：
std::mutex mtx; std::lock_guard<std::mutex> lock(mtx); // 这里随便操作共享数据 // 作用域结束时自动解锁std::unique_lock 比 lock_guard 更灵活，可以延迟加锁、手动解锁、配合条件变量使用。工程上建议：能 lock_guard 就 lock_guard，需要复杂锁策略时再上 unique_lock，避免过度设计。
5.3 std::async 与 future：从“手搓线程”到“拿结果”
如果你只是想让一个任务异步执行并拿到结果，std::async比手写 std::thread 更合适。它把“执行策略+线程创建+结果获取”封装成一套，返回一个std::future<T>：
std::future<int> f = std::async([] { return 42; }); int result = f.get(); // 阻塞直到结果就绪这里有两点要说明。第一，async 不保证一定开新线程，实现可以延迟到 get() 时才同步执行。这意味着你无法依赖它做高并发性能优化，它更适合“并发编程的便利接口”而非“性能工具”。第二，future.get() 只能调用一次，之后 future 状态就无效了。想多线程等待同一个任务，用 std::shared_future。
我个人的直觉是：简单异步任务用 async，明确要对线程生命周期精细控制时用 std::thread + 条件变量。别把两者搞混，async 就算不真的开线程，它提供的 exception 传递能力依然有价值——子线程抛出的异常会在 get() 时重新抛出到调用线程。
6. 从 C++98 迁移到 C++11 的实操记录
6.1 编译器与编译选项
迁移第一步是确认工具链支持 C++11。当前主流编译器对 C++11 的支持都已经非常完备，关键是编译选项要对。以 GCC 为例，老项目可能还在用默认的标准模式，需要显式加上：
g++ -std=c++11 -Wall -Wextra -O2 -o app main.cppClang 同样支持-std=c++11，MSVC 则需要在项目属性里设置“C++ 语言标准”为 C++11 或更高。如果你用的是 CMake，在 CMakeLists.txt 里加：
set(CMAKE_CXX_STANDARD 11) set(CMAKE_CXX_STANDARD_REQUIRED ON)这一步只改编译标准，先不动代码。编译错误通常在可接受范围，因为 C++11 大体向后兼容 C++98，少数不兼容点集中在模板实例化和一些新关键字上。改完保证老代码依然跑得通，再开始逐渐替换写法——这种“先开标准，再改代码，分模块推进”的节奏最稳。
6.2 迁移节奏：从替换写法到重设计
我把迁移分成三步，每步之间隔一段时间跑测。
第一步：全局替换 NULL 为 nullptr，把裸 new/delete 的内存池改成 unique_ptr。这阶段不改业务逻辑，只是让资源归属变得清楚。凡是以前“哪个函数 new 了，调用方就得负责 delete”的地方，都改成“工厂函数返回 unique_ptr，调用方只管持有”。注意 unique_ptr 不可拷贝，但可以按值返回，这正是移动语义的功劳。
第二步：把手工循环改成范围 for，把函数对象改成 lambda，把push_back(临时对象)改成emplace_back(参数)。emplace_back 的好处是直接在容器内部构造对象，省去一次临时对象构造和移动。比如：
items.push_back(Item("name", 10)); // 构造临时对象，再移动/拷贝进容器 items.emplace_back("name", 10); // 直接在容器内构造第三步：为重要的大对象补全移动构造，关键路径上的容器传参改为 const 引用或按值接收再移动。这一步要谨慎，先跑单元测试和性能基准，确认移动语义真的生效。
6.3 实战示例：改造一个老式工厂函数
假设原来有一个“创建对象”的函数：
Widget* createWidget() { Widget* w = new Widget(); // 初始化... return w; } // 调用方 Widget* w = createWidget(); // ... delete w;这段代码的问题是：调用方可能忘记 delete，或者中途抛异常导致 w 泄漏。C++11 改造成：
std::unique_ptr<Widget> createWidget() { std::unique_ptr<Widget> w(new Widget()); // 初始化... return w; } // 调用方 auto w = createWidget();不需要手动 delete，作用域结束时自动释放。如果这个 Widget 要被多个对象共享，就把 unique_ptr 换成 shared_ptr。这个改造在代码里可能只是替换类型，但它把“谁拥有谁释放”这个模糊的问题彻底清晰化了，我认为这是 C++11 新特性最重要的实际价值：让资源所有权成为类型的一部分，从设计上消灭泄漏。
7. 避坑指南：C++11 开发中常见的疑难问题
7.1 auto 推导不符合预期
症状：用 auto 接收一个const Widget&，后面修改这个变量，发现改动只在局部生效。原因是 auto 剥掉了引用和 const。解法：想要引用就写auto&，想要 const 引用就写const auto&。不要想着编译器一定理解你的意图，它只是机械执行规则。
7.2 lambda 捕获 this 造成悬垂
症状：在成员函数里写了[this] { ... }，把 lambda 存起来，等对象销毁后再调用，访问到已释放的成员变量。解法：如果回调生命周期可能超过当前对象，考虑使用弱回调机制（比如配合 shared_ptr 和 weak_ptr），或者在对象销毁时主动注销回调。不要以为值捕获[=]就能规避——它捕获的是 this 指针的拷贝，不是对象本身，对象照样悬垂。
7.3 移动没有生效，性能没提升
症状：类写了移动构造函数，vector 扩容依然走拷贝。最常见原因是移动构造函数没标 noexcept。标准库容器在元素移动可能抛异常时，会为强异常保证而退回拷贝。另一个原因是类里有不可移动的成员（比如 const 成员），导致编译器无法生成移动操作。解法：显式=default或自己实现，并标 noexcept。
7.4 范围 for 中修改容器导致崩溃
症状：遍历过程中调用了 erase，程序随机崩溃。原因是迭代器失效。解法：不要在范围 for 里做结构性修改。可以先收集需要删除的索引，循环结束后再统一处理；或者改用普通 for 循环结合算法。
7.5 智能指针循环引用
症状：两个对象互相持有 shared_ptr，程序结束时内存泄漏，因为引用计数永远到不了 0。解法：设计时把“父持有子”用 shared_ptr、“子反向引用父”用 weak_ptr。weak_ptr 不增加引用计数，需要访问时通过 lock() 提升为 shared_ptr，提升失败说明对象已经销毁。
7.6 列表初始化与圆括号的语义混淆
症状：std::vector<int> v(10)和v{10}完全不同。前者是 10 个默认值，后者是 1 个值为 10 的元素。想要 n 个同值时用圆括号，想要用 initializer_list 显式指定元素时用花括号。这个细节容易在代码评审里溜过去，但运行结果可能大不相同。
7.7 线程 detach 后访问已销毁对象
症状：子线程访问调用者局部变量导致崩溃。解法：线程函数要么完全按值接收所有数据，要么在退出子线程之前 join，而不是 detach。如果确实需要后台运行且不等待，就把所需数据用 value 拷贝进线程。
8. 工具链与生态变化：不止是语法更新
C++11 带来的不只是关键字和库，它对整个工具链和编码规范也有持续影响。例如std::function让回调类型统一，以前用函数指针和仿函数接口混杂的代码，现在可以统一用一个可调用对象类型。std::bind虽然现在被 lambda 压制，但它实现“部分函数应用”的思路在绑定参数上仍然有存在价值。std::array补上了固定数组的标准容器缺口，std::unordered_map让哈希表进入标准库，这些库组件让 C++ 程序员不再被迫依赖第三方库来补基本数据结构的短板。
编码规范方面，团队项目里我一般建议制定几条硬性约定：一是所有新代码必须开启 C++11 编译标准；二是禁止裸 new/delete，资源一律用智能指针或容器；三是禁止 NULL，统一 nullptr；四是所有回调优先用 lambda，而不是手写仿函数；五是移动构造函数必须标记 noexcept，否则代码评审不给过。这几条不起眼，但把团队的代码风格从“C++98 风格”拽到“现代 C++ 风格”，长期收益非常明显。
对于编译器比较老、暂时无法升级的环境，还有一个折中思路：先把代码组织成可维持 C++98 的形态，但把新特性的种子埋进独立模块里，等工具链允许时再整体切换。我见过不少团队是这样过渡的，把平台抽象层先跑在 C++11 上，业务代码逐步跟随。
9. 一些补充技巧：怎么写更地道的 C++11
写到最后，分享几个我在实际项目里逐渐形成的习惯。
第一，返回值直接返回对象，不要返回指针。在 C++11 移动语义和 NRVO 的加持下，按值返回大对象几乎不需要担心拷贝开销。如果你还要担心，先测性能，别靠猜。
// 推荐 std::vector<int> makeData() { std::vector<int> v; v.reserve(1000); for (int i = 0; i < 1000; ++i) v.push_back(i); return v; }第二，能用emplace_back的时候优先用，尤其当元素构造参数不是左值而是多个参数时。它会减少一次移动的调用。注意它并不总是最优，如果已经有一个现成对象，push_back(std::move(obj))和emplace_back(std::move(obj))差别不大，不必抠得过于琐碎。
第三，shared_ptr 不要过度使用。默认优先 unique_ptr，只有在真正需要共享所有权时才升级到 shared_ptr。shared_ptr 的原子引用计数在多线程场景有开销，而且循环引用问题会引入额外的心智负担。
第四，使用const关键字配合 auto 非常重要。看到一个const auto&，读者马上知道这个循环是只读的，意图清清楚楚。
我自己的体会是：C++11 新特性真正改变了我的编程习惯，不止是“多记住几个新语法”。过去写代码第一反应是“这个对象怎么管理”，现在第一反应是“这个对象归谁所有，应该怎么表达所有权”。过去的循环是“从哪到哪怎么遍历”，现在是“我要对每个元素做什么操作”，逻辑和实现分离了。过去写多线程要想平台 API 怎么封装，现在直接写标准库，跨平台讲起来也轻松很多。
如果你正准备在自己的项目里引入 C++11，我给的最后建议是：不要试图一晚上把所有特性都用上，那样代码风格反而会变得花哨且难维护。把核心的智能指针、nullptr、auto、范围 for、lambda 用起来，你就已经站在了现代 C++ 的门槛内。移动语义和并发可以边用边学，它们是锦上添花的深度工具。等项目习惯了这个节奏，再回头看那些老代码，你会明显感觉到：语言没有变，但写代码的人看待问题的方式，已经不一样了。
