C++11 新特性深度解析：从可变参数模板到 Lambda 表达式

5.3 default 和 delete

5.3.1 概念

C++11 允许更精细地控制默认函数的生成。若因定义了其他函数导致某些默认函数未生成（如定义了拷贝构造则不再生成移动构造），可使用 = default 显式请求生成。

若希望禁止某些函数被调用，C++98 需将其设为私有且不实现，C++11 则直接使用 = delete 标记为删除函数，编译期报错。

5.3.2 最佳实践

合理使用 default 和 delete 可明确表达设计意图，防止隐式行为带来的风险。

5.4 目标构造函数和委托构造函数

了解即可。目标构造函数指基类构造函数，委托构造函数指本类构造函数调用同类其他构造函数。二者有助于减少代码重复。

5.5 final 和 override

这两个关键字用于继承体系中的多态控制。

• override：强制派生类虚函数重写基类虚函数，若签名不匹配则编译报错。
• final：阻止后续类进一步重写当前虚函数或继承当前类。

6. C++11：STL 的变化

6.1 新的容器

C++11 新增了 array、forward_list、unordered_map 和 unordered_set。其中真正高频使用的是无序关联容器 unordered_map 和 unordered_set。

6.2 新的接口

重点在于右值引用和移动语义相关的插入接口（push/insert/emplace）、移动构造/赋值以及 initializer_list 版本的构造器。其他如 cbegin/cend 等辅助接口按需查阅文档即可。

6.3 范围 for

范围 for 遍历简化了容器迭代写法，底层依赖迭代器实现，是 STL 交互的重要基础。

7. Lambda 表达式

7.1 Lambda 表达式的语法

Lambda 本质是匿名函数对象，可定义在函数内部。由于没有具体类型名，通常使用 auto 接收。

格式如下：

[capture-list](parameters)->return type { function body }

• capture-list：捕捉列表，决定外部变量的访问方式（传值/传引用）。不能省略。
• parameters：参数列表，若无参可连同括号省略。
• ->return type：返回值类型，可省略由编译器推导。
• function body：函数体，不可省略。

7.2 Lambda 的应用场景

相比函数指针和仿函数，Lambda 定义更简洁。适用于线程执行逻辑、智能指针定制删除器等场景。

例如在排序操作中，无需额外定义仿函数结构体，直接在 sort 中嵌入 Lambda 即可完成比较逻辑。

7.3 捕捉列表

7.3.1 概念

Lambda 默认只能访问自身参数和局部变量。访问外层变量需显式或隐式捕捉。

1. 显式捕捉：[x, y, &z] 表示 x、y 传值，z 传引用。
2. 隐式捕捉：[=] 隐式传值，[&] 隐式传引用。编译器自动识别使用的变量。
3. 混合捕捉：[=, &x] 其余传值，x 传引用。首元素必须是 = 或 &。

默认情况下，传值捕捉的对象是 const 的。添加 mutable 修饰符后可修改副本，但不影响实参。

注意：静态局部变量和全局变量无需捕捉，可直接访问。

7.4 Lambda 的原理

Lambda 底层是编译器生成的仿函数类。不同的 Lambda 对应不同的类名，参数、返回类型和函数体映射到仿函数的 operator()。捕捉列表变量成为仿函数类的成员变量，通过构造函数初始化。

C++11 完整代码示例与实践演示

list.h

#pragma once
namespace jqj {
    // --------------链表节点结构--------------
    template<class T>
    struct list_node {
        list_node<T>* _next;
        list_node<T>* _prev;
        T _data;

        list_node(const T& x = T()) : _next(nullptr), _prev(nullptr), _data(x) {}
    };

    // --------------链表迭代器--------------
    template<class T, class Ref, class Ptr>
    struct list_iterator {
        using Self = list_iterator<T, Ref, Ptr>;
        using Node = list_node<T>;
        Node* _node;

        list_iterator(Node* node) : _node(node) {}

        Ref operator*() { return _node->_data; }
        Ptr operator->() { return &_node->_data; }

        Self& operator++() {
            _node = _node->_next;
            return *this;
        }
        Self operator++(int) {
            Self tmp(*this);
            _node = _node->_next;
            return tmp;
        }
        Self& operator--() {
            _node = _node->_prev;
            return *this;
        }
        Self operator--(int) {
            Self tmp(*this);
            _node = _node->_prev;
            return tmp;
        }

        bool operator!=(const Self& s) const { return _node != s._node; }
        bool operator==(const Self& s) const { return _node == s._node; }
    };

    // --------------链表主体类--------------
    template<class T>
    class list {
        using Node = list_node<T>;
    public:
        using iterator = list_iterator<T, T&, T*>;
        using const_iterator = list_iterator<T, const T&, const T*>;

        iterator begin() { return iterator(_head->_next); }
        iterator end() { return iterator(_head); }
        const_iterator begin() const { return const_iterator(_head->_next); }
        const_iterator end() const { return const_iterator(_head); }

        void empty_init() {
            _head = new Node;
            _head->_next = _head;
            _head->_prev = _head;
        }

        list() { empty_init(); }

        list(initializer_list<T> il) {
            empty_init();
            for (auto& e : il) push_back(e);
        }

        template<class InputIterator>
        list(InputIterator first, InputIterator last) {
            empty_init();
            while (first != last) {
                push_back(*first);
                ++first;
            }
        }

        list(size_t n, T val = T()) {
            empty_init();
            for (size_t i = 0; i < n; ++i) push_back(val);
        }

        ~list() {
            clear();
            delete _head;
            _head = nullptr;
            _size = 0;
        }

        void swap(list<T>& lt) {
            std::swap(_head, lt._head);
            std::swap(_size, lt._size);
        }

        void clear() {
            iterator it = begin();
            while (it != end()) {
                it = erase(it);
            }
        }

        template<class... Args>
        void emplace_back(Args&&... args) {
            emplace(end(), forward<Args>(args)...);
        }

        template<class... Args>
        void emplace(iterator pos, Args&&... args) {
            Node* cur = pos._node;
            Node* prev = cur->_prev;
            Node* newnode = new Node(forward<Args>(args)...);
            prev->_next = newnode;
            newnode->_prev = prev;
            newnode->_next = cur;
            cur->_prev = newnode;
            ++_size;
        }

        void push_back(T&& x) {
            insert(end(), forward<T>(x));
        }

        void push_front(const T& x) {
            insert(begin(), x);
        }

        void pop_back() {
            erase(--end());
        }

        void pop_front() {
            erase(begin());
        }

        void insert(iterator pos, const T& x) {
            Node* cur = pos._node;
            Node* prev = cur->_prev;
            Node* newnode = new Node(x);
            prev->_next = newnode;
            newnode->_prev = prev;
            newnode->_next = cur;
            cur->_prev = newnode;
            ++_size;
        }

        void insert(iterator pos, T&& x) {
            Node* cur = pos._node;
            Node* prev = cur->_prev;
            Node* newnode = new Node(move(x));
            prev->_next = newnode;
            newnode->_prev = prev;
            newnode->_next = cur;
            cur->_prev = newnode;
            ++_size;
        }

        iterator erase(iterator pos) {
            Node* cur = pos._node;
            Node* prev = cur->_prev;
            Node* next = cur->_next;
            prev->_next = next;
            next->_prev = prev;
            delete cur;
            --_size;
            return next;
        }

        size_t size() const { return _size; }

    private:
        Node* _head;
        size_t _size = 0;
    };
}

Test.cpp

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <vector>
#include <map>
#include <list>
#include <string>
#include <algorithm>
#include <assert.h>

using namespace std;

namespace Alice {
    class string {
    public:
        typedef char* iterator;
        typedef const char* const_iterator;

        iterator begin() { return _str; }
        iterator end() { return _str + _size; }
        const_iterator begin() const { return _str; }
        const_iterator end() const { return _str + _size; }

        string(const char* str = "") : _size(strlen(str)), _capacity(_size) {
            cout << "string(char* str)-构造" << endl;
            _str = new char[_capacity + 1];
            strcpy(_str, str);
        }

        void swap(string& s) {
            std::swap(_str, s._str);
            std::swap(_size, s._size);
            std::swap(_capacity, s._capacity);
        }

        string(const string& s) {
            cout << "string(char* str)-拷贝构造" << endl;
            reserve(s._capacity);
            for (auto ch : s) push_back(ch);
        }

        string(string&& s) {
            cout << "string(char* str)-移动构造" << endl;
            swap(s);
        }

        string& operator=(const string& s) {
            cout << "string(char* str)-拷贝赋值" << endl;
            if (this != &s) {
                _str[0] = '\0';
                _size = 0;
                reserve(s._capacity);
                for (auto ch : s) push_back(ch);
            }
            return *this;
        }

        string& operator=(string&& s) {
            cout << "string(char* str)-移动赋值" << endl;
            swap(s);
            return *this;
        }

        ~string() {
            delete[] _str;
            _str = nullptr;
        }

        char& operator[](size_t pos) {
            assert(pos < _size);
            return _str[pos];
        }

        void reserve(size_t new_capacity) {
            if (new_capacity > _capacity) {
                char* tmp = new char[new_capacity + 1];
                if (_str) strcpy(tmp, _str);
                delete[] _str;
                _str = tmp;
                _capacity = new_capacity;
            }
        }

        void push_back(char ch) {
            if (_size >= _capacity) {
                size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
                reserve(newcapacity);
            }
            _str[_size] = ch;
            ++_size;
            _str[_size] = '\0';
        }

        string& operator+=(char ch) {
            push_back(ch);
            return *this;
        }

        const char* c_str() const { return _str; }
        size_t size() const { return _size; }

    private:
        char* _str = nullptr;
        size_t _size = 0;
        size_t _capacity = 0;
    };
}

struct Date {
    int _y;
    int _m;
    int _d;
    Date(int year, int month, int day) : _y(year), _m(month), _d(day) {}
};

struct Goods {
    string _name;
    double _price;
    int _evaluate;

    Goods(const char* str, double price, int evaluate)
        : _name(str), _price(price), _evaluate(evaluate) {}
};

int main() {
    // emplace_back 测试
    list<Alice::string> lt;
    lt.emplace_back("111111111111111111");

    // 日期类测试
    list<Date> lt_date;
    lt_date.emplace_back(2025, 11, 18);

    // Lambda 排序测试
    vector<Goods> v = {
        {"苹果", 2.1, 5},
        {"香蕉", 3, 4},
        {"橙子", 2.2, 3},
        {"菠萝", 1.5, 4}
    };

    sort(v.begin(), v.end(), [](const Goods& gl, const Goods& gr) {
        return gl._price < gr._price;
    });

    // Lambda 捕获测试
    int a = 0, b = 1;
    auto func1 = [a, &b]() mutable {
        int ret = a + b;
        b++;
        return ret;
    };
    cout << func1() << endl;

    return 0;
}