C++11 新特性全解析（附代码示例）

一、概述

C++11（原名 C++0x）是 ISO/IEC 14882:2011 的正式名称，被誉为 C++ 自 C++98 发布以来最重要的一次升级。它将现代语言的高效抽象（自动类型推导、Lambda、右值引用）与底层性能（移动语义、完美转发、内存序）熔于一炉，直接奠定了后续 C++14/17/20 的现代化范式。

二、核心语言层面改进

2.1 auto / decltype / 拖尾返回类型

// auto 示例：编译器从初始化自动推导类型
auto i = 42;           // → int
auto d = 3.14;         // → double
auto s = "hello";      // → const char* (注意不是 std::string)
auto vec = std::vector<int>{1,2,3};

// C++98 年代需要写一整行迭代器，现在只需：
for (auto it = vec.begin(); it != vec.end(); ++it) { /* ... */ }

// auto 不会保留顶层 const/引用，需要显式声明
const int& ref_i = i;
auto       a = ref_i;   // → int（拷贝，const& 都被丢弃）
auto&      b = ref_i;   // → const int&
auto&&     c = 100;     // → int&&（右值引用绑定纯右值）
const auto& d = ref_i;   // → const int&

// decltype：推导表达式的"声明类型"（保留 const/引用）
decltype(ref_i)  x = i;   // → const int&
decltype((i))    y = i;   // → int&（注意双括号 → 左值表达式 → 引用）
decltype(1+2)  z = 3;   // → int（纯右值）

// 拖尾返回类型：返回值类型依赖参数类型
template<typename T, typename U>
auto add(T t, U u) -> decltype(t + u) {
    return t + u;
}

// 进阶：decltype(auto) 示例（此为 C++14，此处对比方便理解）
// template<typename T> decltype(auto) foo(T& x) { return ++x; }

2.2 统一初始化与初始化列表 initializer_list

// (1) 基础类型 & POD 结构体：不再区分 = / () / {}
int a{10};              // C++11 统一语法
double d{3.14};
int arr[]{1,2,3,4};

struct Point { int x, y; };
Point p{100, 200};      // POD 聚合初始化

// (2) STL 容器：无需 push_back 多次
std::vector<int> vi{1,2,3,4,5};
std::map<std::string, int> mp = { {"C++", 98}, {"Rust", 2015} };

// (3) 防止窄化转换（编译错误！）
int big = 100000;
// short s{ big };    // ❌ 错误：narrowing conversion
short s = big;         // ✅ 但"="静默截断（推荐用花括号！）

// (4) 自定义类支持 initializer_list 构造
class MyBag {
public:
    MyBag(std::initializer_list<int> list) {
        for (auto v : list) data_.push_back(v);
    }
    size_t size() const { return data_.size(); }
private:
    std::vector<int> data_;
};
MyBag b{ 1,2,3,4,5 };     // 直接用花括号构造自定义容器

2.3 nullptr 与 enum class 强类型枚举

/* ---------------- nullptr 解决 NULL 的 3 大经典问题 ---------------- */
void f(int);       // #1
void f(char*);     // #2
f(0);               // ✅ 调用 #1，但用户本意可能是空指针
// f(NULL);          // ❌ C++03 二义性 / 大部分实现仍会走 #1
f(nullptr);         // ✅ 无歧义走 #2

/* ---------------- enum class 强枚举 ---------------- */
// 传统枚举的问题：隐式转 int + 枚举器泄露到外层作用域
enum OldColor { Red, Green, Blue };   // Red/Green/Blue 泄露
enum OldTraffic { Red, Yellow, Green }; // ❌ 重定义报错！

// C++11 强类型枚举：作用域内、不隐式转整型、可指定底层类型
enum class Color : uint8_t { Red = 1, Green = 2, Blue = 4 };
enum class Traffic : uint8_t { Red, Yellow, Green };

Color c = Color::Green;
int i = static_cast<int>(c);  // ✅ 必须显式转整数（= 2）
Traffic t = Traffic::Red;    // ✅ 命名空间隔离，不再和 Color::Red 冲突

// 还能前置声明（底层类型必须一致）
enum class Status : int;   // 前置声明
Status get();              // 放到头文件里做接口

2.4 右值引用 &&、移动语义、完美转发 std::forward

class BigBuffer {
public:
    explicit BigBuffer(size_t n) : size_(n), data_(new char[n]) {
        std::cout << "ctor(size_t)\n";
    }

    // 深拷贝构造：必须复制堆上的整块内存（昂贵）
    BigBuffer(const BigBuffer& o) : size_(o.size_), data_(new char[o.size_]) {
        std::memcpy(data_, o.data_, o.size_);
        std::cout << "copy ctor (deep copy)\n";
    }

    // 移动构造：O(1) 偷取对方的指针，避免深拷贝
    BigBuffer(BigBuffer&& o) noexcept
        : size_(o.size_), data_(o.data_) {
        o.size_ = 0;
        o.data_ = nullptr;     // 把源对象置空，避免 double free
        std::cout << "move ctor (steal resources)\n";
    }

    ~BigBuffer() { delete[] data_; }
private:
    size_t size_;
    char*  data_;
};

BigBuffer makeBuffer() {
    BigBuffer buf(1024 * 1024);   // 1MB 缓冲区
    return buf;               // C++11 下直接移动（RVO 更优）
}

int main() {
    BigBuffer a(1024);
    BigBuffer b = a;                   // 调用深拷贝（因为 a 是左值）
    BigBuffer c = std::move(a);      // ✅ 调用移动构造，a 变为空
    BigBuffer d = makeBuffer();      // ✅ RVO + 移动，零深拷贝

    /* -------- 完美转发 std::forward<T> --------- */
    // make_unique 的最简化实现：保留左/右值属性送入构造函数
    template<typename T, typename... Args>
    std::unique_ptr<T> my_make_unique(Args&&... args) {
        return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
    }

    std::vector<BigBuffer> v;
    v.reserve(10);
    v.emplace_back(1024);         // ✅ 直接原地构造，无拷贝无移动
}

2.5 =default / =delete / 继承构造函数 using

/* =default & =delete 示例 */
class NoCopy {
public:
    NoCopy() = default;                     // 保留默认构造
    ~NoCopy() = default;

    NoCopy(const NoCopy&) = delete;         // ❌ 禁止拷贝
    NoCopy& operator=(const NoCopy&) = delete;

    NoCopy(NoCopy&&) = default;               // ✅ 允许移动
    NoCopy& operator=(NoCopy&&) = default;

    // 进阶技巧：=delete 可以用于任意函数，禁止某些重载
    void takeDouble(double);
    void takeDouble(int) = delete;   // 禁止隐式从 int 提升
};

NoCopy a, b;
// NoCopy c = a;   // ❌ 编译错误：已删除的函数
NoCopy d = std::move(a);   // ✅ OK（移动）
// takeDouble(42);  // ❌ 禁止传入整数参数，避免隐式提升
takeDouble(3.14);            // ✅ OK（double）

/* 继承构造函数 using Base::Base */
class Base {
public:
    Base(int a, const std::string& b) : x_(a), y_(b) {}
protected:
    int x_; std::string y_;
};
class Derived : public Base {
public:
    using Base::Base;      // ✅ 把 Base(int,string) 构造函数直接"借"过来
    void extraWork() { x_ *= 2; }
};
Derived d(100, "hello");   // 等价于直接调用 Base 构造，无需再转写

2.6 Lambda 表达式（闭包）

int main() {
    // 形式：[capture](params) -> Ret { body }
    auto plusOne = [](int x) -> int { return x + 1; };
    std::cout << plusOne(5) << "\n";   // 6

    // (1) 按值捕获 [=] ：拷贝一份外部变量
    int factor = 10;
    auto mul = [=](int x) { return x * factor; };
    std::cout << mul(6) << "\n";   // 60

    // (2) 按引用捕获 [&]：直接操作外部变量
    int sum = 0;
    std::for_each(v.begin(), v.end(),
        [&](int x) { sum += x; });

    // (3) 混合捕获：某些按引用，某些按值
    std::string name = "C++11";
    auto greet = [&sum, name]() { return name + ": sum=" + std::to_string(sum); };

    // (4) mutable：允许修改"按值捕获"的副本
    int cnt = 0;
    auto tick = [=]() mutable { return ++cnt; };  // cnt 的副本自增
    tick(); tick();   // 外部 cnt 仍 = 0

    // (5) 典型实战：用于 STL 算法 & std::function 回调
    std::vector<int> arr{3,1,4,1,5,9,2};
    int threshold = 3;
    auto gt_cnt = std::count_if(arr.begin(), arr.end(),
        [=](int x){ return x > threshold; });   // = 4（4,5,9,≥4 均大于 3 共 4 个）

    // 自定义排序规则：按绝对值降序
    std::sort(arr.begin(), arr.end(), [](int a, int b) {
        return std::abs(a) > std::abs(b);
    });
}

2.7 范围 for（Range-based for）

std::vector<std::string> names = {"Alice","Bob","Carol"};

// 按值：元素被拷贝（适合小对象）
for (auto s : names) std::cout << s << ' ';

// 按引用：直接修改原容器
for (auto& s : names) s += ".com";

// const 引用：只读最高效（推荐）
for (const auto& s : names) std::cout << s << '\n';

// 原生数组也可使用
int arr[] = {1,2,3,4};
int total = 0;
for (auto e : arr) total += e;     // total = 10

// 自定义类型：只要提供 begin()/end()（或 ADL 的 free begin/end）

2.8 override / final

struct Base {
    virtual void foo(int x)   const;
    virtual void bar(double d);
    virtual ~Base() = default;
};

struct Derived : public Base {
    // ❌ 无 override 时的经典 bug：const、参数类型任何不一致，编译器默认是"新函数"
    // void foo(int x);          // 旧写法，静默变成 Derived::foo(int) 非 const 的全新虚函数

    // ✅ 加 override：签名不匹配就编译错误（可及时发现）
    void foo(int x) const override;

    // final：子类不能再重写 bar 了
    void bar(double d) final override;
};

struct Derived2 final : Derived {   // final 类：不允许被继承
    // void bar(double) override;   // ❌ 编译错误：bar 已经在 Derived 中被 final
};
// struct Derived3 : Derived2 {};  // ❌ Derived2 被 final 禁止继承

2.9 using 模板别名 / static_assert / noexcept

/* 1) using 别名模板 */
template<typename T>
using VecMap = std::map<std::string, std::vector<T>>;   // 一行搞定模板别名

VecMap<int>       userScores;   // 等价于 map<string, vector<int>>
VecMap<std::string> userTags;     // 等价于 map<string, vector<string>>

/* 2) static_assert 编译期断言 + 标准库 type_traits */
#include <type_traits>

template<typename T>
class PodOnlyContainer {
    static_assert(std::is_trivial<T>::value, "T 必须是 trivial(POD) 类型");
    static_assert(sizeof(T) <= 1024, "T 过大");
};
PodOnlyContainer<int> a;            // OK
// PodOnlyContainer<std::string> b;  // ❌ 编译报错，并打印中文消息

/* 3) noexcept：不会抛异常的强承诺，影响 STL 容器扩容策略、std::move_if_noexcept 等 */
struct S {
    S(S&&) noexcept { /* 不抛异常 */ }     // 推荐给移动 ctor/assignment 加 noexcept
    void fastPath() noexcept;
    void slowPath();                   // 未声明 noexcept 等价于 可能抛异常
};
// std::vector<S> 在 rehash/reallocate 时会直接使用移动构造（而非拷贝构造）

三、标准库层面改进

3.1 智能指针家族：unique_ptr / shared_ptr / weak_ptr

#include <memory>

struct Widget {
    int id;
    Widget(int i) : id(i) { std::cout << "Widget " << id << " 构造\n"; }
    ~Widget()       { std::cout << "Widget " << id << " 析构\n"; }
};

/* 1) unique_ptr：独占所有权，零开销，可移动不可拷贝 */
{
    auto pw = std::unique_ptr<Widget>(new Widget(1));
    // 推荐 C++14：auto pw = std::make_unique<Widget>(1);  // 防异常泄露
    // auto pw2 = pw;           // ❌ 禁止拷贝
    auto pw3 = std::move(pw);   // ✅ 所有权转移
} // ← 作用域结束：自动 delete Widget 1

/* 2) shared_ptr：引用计数共享，最后一个持有者销毁时 delete */
{
    auto sp1 = std::make_shared<Widget>(10);  // ref=1
    {
        auto sp2 = sp1;                        // ref=2
        std::cout << "内部作用域 ref=" << sp1.use_count() << '\n';
    }                                               // 退出内部 ref=1
} // ← ref 归零 → 自动 delete Widget 10

/* 3) weak_ptr：打破循环引用，不增加引用计数 */
struct Node {
    std::shared_ptr<Node> next;     // 用 shared_ptr 持有后继节点
    std::weak_ptr<Node>   prev;     // ← 前驱用 weak_ptr，避免双向链表循环泄漏
    ~Node() { std::cout << "Node 释放\n"; }
};
auto a = std::make_shared<Node>();
auto b = std::make_shared<Node>();
a->next = b;   b->prev = a;    // ✅ 双链表：无循环引用，离开作用域后 2 个 Node 都会正常释放

// weak_ptr 读取前先 lock()，拿得到才是有效对象
if (auto prev = a->prev.lock()) {
    std::cout << "prev alive" << "\n";
}

3.2 新增容器：std::array / std::forward_list / 无序容器

// 1) std::array —— 栈上定长数组 + STL 接口
std::array<int, 5> arr = {1,2,3,4,5};
std::sort(arr.begin(), arr.end());  // 直接算法
for (auto x : arr) /* ... */;
auto* raw = arr.data();              // 仍可取底层 C 指针（和 C 接口互操作）

// 2) forward_list —— 单向链表，省内存
std::forward_list<int> fl = {1,1,2,3,5,8};
fl.insert_after(fl.before_begin(), 0);  // O(1) 插入头部，得到 0,1,1,2,3,5,8
fl.unique();                            // 去重：0,1,2,3,5,8

// 3) unordered_map —— 哈希表 O(1) 查找
std::unordered_map<std::string, int> ages = {
    {"Yang", 30}, {"Li", 25}, {"Wang", 28}
};
ages["Zhang"] = 27;
auto it = ages.find("Li");
if (it != ages.end()) std::cout << it->second << "\n";   // 25

// 自定义类型做键：需提供 Hash 函数 + operator==（简化示例见 CppReference）

四、并发与多线程（语言第一次原生支持）

4.1 std::thread / std::mutex / condition_variable / std::async

#include <thread>
#include <mutex>
#include <condition_variable>
#include <future>
#include <queue>

/* -------- 1) 最基础 thread + mutex 竞争保护 -------- */
int counter = 0;
std::mutex mtx;

void worker(int id) {
    for (int i = 0; i < 1000; ++i) {
        std::lock_guard<std::mutex> lock(mtx);  // 作用域结束自动 unlock（异常安全）
        ++counter;
    }
}
int main() {
    std::thread t1(worker, 1), t2(worker, 2);
    t1.join(); t2.join();
    std::cout << "counter = " << counter << "\n";   // 恒定 = 2000
}

/* -------- 2) 生产者-消费者：condition_variable -------- */
std::queue<int> g_queue;
std::condition_variable g_cv;

void produce() {
    for (int i = 1; i <= 10; ++i) {
        {
            std::lock_guard<std::mutex> lck(mtx);
            g_queue.push(i);
        }                         // 先解锁再通知，性能更好
        g_cv.notify_one();
    }
}
void consume() {
    while (true) {
        std::unique_lock<std::mutex> lck(mtx);
        g_cv.wait(lck, []{ return !g_queue.empty(); });   // wait 自带谓词版本：自动防虚假唤醒
        int v = g_queue.front(); g_queue.pop();
        lck.unlock();              // 处理前先解锁，减少临界区
        // process v ...
        if (v == 10) break;
    }
}

/* -------- 3) async / future / promise：拿返回值 -------- */
// 写法 A：std::async — 高级任务 API
std::future<long long> f1 = std::async(std::launch::async, [](){
    long long s = 0;
    for (int i = 0; i <= 1000000; ++i) s += i;
    return s;
});
long long sum = f1.get();        // 阻塞，拿到异步返回值 500000500000

// 写法 B：std::promise + std::future — 手动设置结果 / 异常
std::promise<std::string> prom;
auto fut = prom.get_future();
std::thread([&]{ prom.set_value("Done from worker"); }).detach();
std::cout << fut.get() << "\n";      // "Done from worker"

4.2 原子操作 & 内存序 std::atomic / memory_order

#include <atomic>

// 最常用：计数器、flag、停止令牌
std::atomic<int>  atmCount{0};
std::atomic<bool> atmStop{false};

void worker() {
    while (!atmStop.load(std::memory_order_acquire)) {
        atmCount.fetch_add(1, std::memory_order_relaxed);   // 计数无需顺序
    }
}

/* 6 种内存序速查（由强到弱）：
 * seq_cst           = 默认值，顺序一致（最强，几乎无风险）
 * acquire / release = 配对使用：读端 acquire 与写端 release 形成同步
 * consume           = 比 acquire 更弱，只保证数据依赖（实际编译器多退化成 acquire）
 * relaxed           = 最松，只保证原子性，不保证跨线程顺序
 */

// compare_exchange_strong：经典无锁栈 push 片段
struct Node { int val; Node* next; };
std::atomic<Node*> g_head{nullptr};

void push(int v) {
    Node* newNode = new Node{v, nullptr};
    newNode->next = g_head.load(std::memory_order_relaxed);
    // CAS：若 head 仍是预期值，则改为新节点；失败时内部把 newNode->next 刷新
    while (!g_head.compare_exchange_weak(
            newNode->next, newNode,
            std::memory_order_release,
            std::memory_order_relaxed)) {
        /* 空转重算 */
    }
}

4.3 时间库 std::chrono 与 <random>

#include <chrono>
#include <random>
#include <thread>

/* chrono：强类型时长/时间点 */
using namespace std::chrono;     // 引入 hours/minutes/seconds/milliseconds 字面量前缀

auto t0 = steady_clock::now();          // steady 稳定时钟，适合计时（不受系统时间回拨影响）
std::this_thread::sleep_for(milliseconds(50));  // 明确 ms，不再有歧义
auto dt = duration_cast<microseconds>(steady_clock::now() - t0);
std::cout << "sleep 实际花费 " << dt.count() << " us\n";

// 类型安全：不做隐式精度丢失转换
// seconds s1 = 3.14;     // ❌ 错误（非整数秒）
// milliseconds ms1 = 3s; // ✅ OK（提升精度）

/* <random>：mt19937 + 分布类替换 rand() */
std::random_device rd;                 // 真随机熵池（硬件支持），用于播种
std::mt19937 gen(rd());                // 伪随机引擎：梅森旋转 19937
std::uniform_int_distribution<>     dist1(1, 100);   // 均匀整数 [1,100]
std::normal_distribution<double>  dist2(0.0, 1.0);  // 标准正态分布 N(0,1)

int dice      = dist1(gen);     // 掷骰子
double noise = dist2(gen);     // 加高斯噪声

4.4 tuple 元组、正则 regex、function/bind

/* 1) tuple：多返回值 / tie 结构化解包 */
std::tuple<std::string, int, double> getUser() {
    return std::make_tuple("Yang", 30, 178.5);
}
int main() {
    // 方式 1：直接 get<N>（C++11 基本做法）
    auto user = getUser();
    std::cout << std::get<0>(user)   // 姓名 "Yang"
              << std::get<1>(user);  // 年龄 30

    // 方式 2：std::tie 一次解包到多个左值变量（C++11/14 惯用手段）
    std::string name; int age; double height;
    std::tie(name, age, height) = getUser();

    /* 2) std::regex 示例：提取邮箱 */
    #include <regex>
    std::string text = "联系邮箱：yang@example.com，抄送到 support@site.org";
    std::regex  emailPat(R"(([a-zA-Z0-9._%+-]+)@([a-zA-Z0-9.-]+\.[a-zA-Z]{2,}))");
    auto it = std::sregex_iterator(text.begin(), text.end(), emailPat);
    for (auto end = std::sregex_iterator(); it != end; ++it) {
        std::cout << "邮箱：" << (*it)[0]          // 整体匹配
                  << "  域="  << (*it)[2] << '\n';  // 第 2 组（域名）
    }

    /* 3) function & bind 统一函数对象 */
    #include <functional>
    void printSum(int a, int b) { std::cout << a + b << '\n'; }

    // function：统一装下所有签名一致的可调用物
    std::function<void(int,int)> fn1 = printSum;
    std::function<void(int,int)> fn2 = [](int a,int b){ std::cout << a*b << '\n'; };

    // bind：把参数"预绑定"，生成新的可调用物（Lambda 多数情况下更直观）
    auto addOne = std::bind(printSum, std::placeholders::_1, 1);
    addOne(41);    // → 等价于 printSum(41, 1) = 42
}

五、C++11 新特性速查对照表