C++11 核心特性实战：Lambda、移动语义与模板进阶

捕获列表详解

捕获列表描述了上下文数据的传递方式（传值还是传引用）：

• [x]：按值捕获变量 x。
• [=]：按值捕获所有父作用域变量（包括 this）。
• [&x]：按引用捕获变量 x。
• [&]：按引用捕获所有父作用域变量（包括 this）。
• [this]：按值捕获当前对象的 this 指针。

注意： 默认情况下，按值捕获的变量在 lambda 内部是不可修改的。如果需要修改，必须加 mutable 关键字。但这只是修改了 lambda 内部的副本，不会影响外部原始变量。

int main() {
    int x = 10;
    auto func = [x]() mutable {
        x = 20; // 修改的是副本
        std::cout << x << std::endl;
    };
    func();
    std::cout << x << std::endl; // 输出仍为 10
    return 0;
}

此外，捕获列表可以混合使用，如 [=, &a] 表示除 a 外其他变量按值捕获，a 按引用捕获。但要注意变量不能重复捕获，且块作用域外的 lambda 捕获列表必须为空。

本质理解

从底层看，lambda 表达式本质上是被编译器包装过的仿函数。编译器会自动生成一个唯一的匿名类，并在其中重载 operator()。这意味着 lambda 也是可调用对象，可以像普通函数一样传递给模板。

类的新增语法

移动构造与移动赋值

C++11 新增了移动构造函数和移动赋值运算符，旨在高效转移资源所有权（如动态内存），避免不必要的深拷贝开销。

如果你没有显式实现移动操作，且未定义析构函数、拷贝构造或拷贝赋值，编译器会生成默认的移动版本。对于内置类型执行字节拷贝，对于自定义类型则尝试调用其移动构造。

class Person {
public:
    Person(const char* name = "", int age = 0)
        :_name(name), _age(age) {}
    
    // 显式指定生成默认移动构造函数
    Person(Person&& p) = default;
    
private:
    std::string _name;
    int _age;
};

int main() {
    Person s1;
    Person s2 = s1;          // 拷贝构造
    Person s3 = std::move(s1); // 移动构造
    return 0;
}

这里使用了 default 关键字强制生成默认函数。当你提供了拷贝构造后，编译器通常不会再生成移动构造，此时可以用 default 显式恢复。

delete 关键字

delete 用于禁止生成默认函数。如果一个类禁用了拷贝构造函数，通常意味着资源不可复制（如独占锁）。此时如果编译器自动生成移动构造函数，可能会破坏设计意图，因此有时需要配合 delete 明确禁用移动操作。

class NonCopyable {
public:
    NonCopyable(const NonCopyable&) = delete;
    NonCopyable& operator=(const NonCopyable&) = delete;
};

可变参数模板

概念与展开

可变参数模板允许函数或类模板接受任意数量的参数，类似于 C 语言的 printf 风格。

template<class... Args>
void ShowList(Args... args) {
    // 参数包展开
}

获取参数个数可以使用 sizeof...(args)。但在实际展开参数包时，由于不支持直接遍历，通常采用递归或逗号表达式技巧。

递归展开

通过特化终止条件和泛化展开条件来实现递归：

// 终止条件：只有一个参数时
template<class T>
void ShowList(const T& t) {
    std::cout << t << std::endl;
}

// 展开条件：至少两个参数
template<class T, class... Args>
void ShowList(T value, Args... args) {
    std::cout << value << " ";
    ShowList(args...); // 递归调用，减少参数包
}

每次调用取出第一个参数，剩余部分构成新的参数包继续递归，直到匹配终止条件。

逗号表达式展开

利用逗号表达式的副作用进行展开，常用于初始化列表或宏替代场景：

template<class T>
void PrintArg(T t) {
    std::cout << t << " ";
}

template<class... Args>
void ShowList(Args... args) {
    int arr[] = {(PrintArg(args), 0)...}; // 利用逗号表达式触发打印
    std::cout << std::endl;
}

这里 (PrintArg(args), 0) 会将每个参数传入 PrintArg 并返回 0 填充数组，确保类型一致。

emplace 系列接口

容器中的 emplace_back 比 push_back 更高效，因为它直接在容器内部构造对象，避免了先构造临时对象再移动的过程。

std::list<std::pair<int, char>> mylist;
mylist.emplace_back(10, 'a');      // 直接构造
mylist.push_back(std::make_pair(20, 'b')); // 先构造再移动

结合可变参数模板，emplace 可以将参数包一路传递到底层构造函数，极大简化了复杂对象的插入逻辑。

包装器

function

std::function 是一个通用的多态函数包装器，能够存储、复制和调用任何可调用对象（函数指针、仿函数、lambda）。

#include <functional>

template<class F, class T>
T useF(F f, T x) {
    static int count = 0;
    std::cout << "count:" << ++count << std::endl;
    return f(x);
}

double f(double i) { return i / 2; }

struct Functor {
    double operator()(double d) { return d / 3; }
};

int main() {
    // 统一类型，模板只实例化一次
    std::function<double(double)> func1 = f;
    std::function<double(double)> func2 = Functor();
    std::function<double(double)> func3 = [](double d) { return d / 4; };
    
    useF(func1, 11.11);
    useF(func2, 11.11);
    useF(func3, 11.11);
    return 0;
}

如果不使用 function，不同可调用对象会导致模板多次实例化，增加二进制体积。使用 function 后，它们被统一为同一类型，静态变量共享，效率更高。

bind

std::bind 用于将函数对象与特定参数绑定，生成一个新的可调用对象。它常与 placeholders 配合使用，占位符 _1, _2 代表后续调用时的实参。

#include <functional>

int Plus(int a, int b) { return a + b; }

class Sub {
public:
    int sub(int a, int b) { return a - b; }
};

int main() {
    // 绑定非静态成员函数，需传入对象实例
    Sub s;
    std::function<int(int, int)> func3 = 
        std::bind(&Sub::sub, s, std::placeholders::_1, std::placeholders::_2);
    
    // 调换参数顺序
    std::function<int(int, int)> func4 = 
        std::bind(&Sub::sub, s, std::placeholders::_2, std::placeholders::_1);
    
    std::cout << func3(1, 2) << std::endl; // 1 - 2
    std::cout << func4(1, 2) << std::endl; // 2 - 1
    return 0;
}

注意：非静态成员函数指针前需加 &，且必须绑定具体的对象实例；静态成员函数则与普通全局函数无异。

以上便是 C++11 中几个关键特性的实战解析。掌握这些工具，能让你的代码更简洁、性能更优。