C++11 新特性全景：右值引用、lambda、auto、decltype 与现代 C++ 的开端

#include <iostream>
using namespace std;
 
struct Point
{
    int _x;
    int _y;
};
 
int main()
{
    int array1[] = { 1, 2, 3, 4, 5 }; // 数组用 {} 初始化
    int array2[5] = { 0 };            // 数组全部置 0
    Point p = { 1, 2 };               // 结构体用 {} 初始化
    return 0;
}

#include <iostream>
using namespace std;
 
class Date
{
public:
    Date(int year = 1, int month = 1, int day = 1)
        : _year(year), _month(month), _day(day)
    {
        cout << "Date(int, int, int)" << endl;   // 走构造函数
    }
 
    Date(const Date& d)
        : _year(d._year), _month(d._month), _day(d._day)
    {
        cout << "Date(const Date&)" << endl;     // 走拷贝构造
    }
 
private:
    int _year;
    int _month;
    int _day;
};
 
int main()
{
    // 内置类型也可以用 {} 初始化
    int x1 = { 2 };
 
    // 本质：用 {2025,1,1} 构造临时对象，再拷贝给 d1
    // 但编译器把"构造临时 + 拷贝构造"优化为"直接构造"，所以只会打印一行 Date(int,int,int)
    Date d1 = { 2025, 1, 1 };
 
    // d2 引用的是 {2024,7,25} 构造出的临时对象（临时对象的生命周期被延长了）
    const Date& d2 = { 2024, 7, 25 };
 
    // 单参数时，C++98 就支持隐式类型转换，可以不用 {}
    Date d3 = { 2025 };
    Date d4 = 2025;
 
    // 列表初始化可以省略 "="
    Date d6 { 2024, 7, 25 };
    int x2 { 2 };
    return 0;
}

#include <iostream>
#include <vector>
using namespace std;
 
struct Vector2
{
    explicit Vector2(int n = 0, int m = 0) : _x(n), _y(m) {}
    int _x, _y;
};
 
int main()
{
    // Vector2 v1 = { 1, 2 };   // 错误：explicit 构造不能用于拷贝列表初始化
    Vector2 v2{ 1, 2 };         // 正确：直接列表初始化可以匹配 explicit 构造函数
    cout << v2._x << "," << v2._y << endl;   // 1,2
 
    // 标准库里也有这种差别：vector 的 (n, value) 构造本身不是 explicit
    vector<int> v{ 5 };         // {5} :只有一个元素 5
    vector<int> w(5);           //  五   :5 个默认构造的元素（都是 0）
    cout << v.size() << " " << w.size() << endl;  // 1 5
    return 0;
}

#include <iostream>
using namespace std;
 
int main()
{
    // ------------------ 普通赋值：允许窄化，静默截断 ------------------
    int a = 3.14;        // 合法：3.14 被截断成 3（编译器可能给 warning）
    cout << a << endl;   // 3
 
    double d = 1e300;
    int b = d;           // 合法：但 1e300 超出 int 范围，行为是未定义的（undefined behavior）
 
    // ------------------ 列表初始化：禁止窄化，编译期报错 ------------------
    // int c{3.14};       // 错误：禁止 double 到 int 的窄化
    // int e{d};          // 错误：同上
    return 0;
}

#include <iostream>
#include <vector>
#include <initializer_list>
using namespace std;
 
int main()
{
    auto il = { 10, 20, 30 };   // il 的类型就是 initializer_list<int>
    for (int e : il)
    {
        cout << e << " ";
    }
    cout << endl;
 
    // 用 N 个值直接初始化 vector：靠的是 initializer_list 版本的构造函数
    vector<int> v1 = { 1, 2, 3, 4, 5 };
    vector<int> v2{ 1, 2, 3, 4, 5 };
 
    // 容器的赋值也支持 initializer_list 版本
    v1 = { 10, 20, 30, 40, 50 };
 
    cout << v2[4] << endl;       // 5
    cout << v2.size() << endl;   // 5
    il.size();                   // 3
 
    // 这里每个元素的类型必须一致；{1, "a"} 这种混合类型会导致编译错误
    // auto bad = { 1, "a" };   // 错误：元素类型不一致
    return 0;
}

#include <iostream>
#include <vector>
#include <string>
using namespace std;
 
int main()
{
    // ---------- pair 的经典坑 ----------
    pair<string, string> p1{ "key", "value" };   // 花括号：两个 string 元素
    cout << p1.first << " " << p1.second << endl;   // key value
 
    // 注意：pair 并没有"接收 3 个参数的"构造函数，下面这句会编译错误：
    // pair<string, string> bad{ "kk", "v", "x" };   // 错误：参数个数不匹配
 
    // vector<pair<string,int>> 这种"里面又是分组 {} "的场景，行为最易踩坑：
    vector<pair<string, int>> x{ { "a", 1 }, { "b", 2 } };   // 花括号：两个 pair 元素
    cout << x.size() << endl;    // 2
    // 而下面这行想表达"1 组 = 2 个元素"？也会报错，因为花括号优先匹配 initializer_list
    // vector<pair<string, int>> y{ 1, {"k","v"} };   // 错误：类型对不上
 
    // 最干净的对比还是 vector<int>：
    vector<int> a(10, 2);    // 圆括号：10 个 2        -> 10
    vector<int> b{10, 2};    // 花括号：两个数 {10,2}  -> 2
    cout << a.size() << " " << b.size() << endl;   // 10 2
 
    // 再比如你自己的类：
    // 只要写了 initializer_list<int> 版本构造，{1,2} 一定优先走它
    struct V {
        V(int n, int m) { cout << "V(int,int)\n"; }
        V(initializer_list<int>) { cout << "V(initializer_list)\n"; }
    };
    V v{ 3, 5 };          // 优先走 initializer_list 版本！
    V vv(3, 5);           // 圆括号才走 V(int,int)
    return 0;
}

#include <iostream>
#include <vector>
#include <initializer_list>
using namespace std;
 
template<class T>
class MyVec
{
public:
    typedef T* iterator;
 
    // 增加一个 initializer_list 版本的构造函数
    MyVec(initializer_list<T> l)
    {
        for (auto e : l)
        {
            push_back(e);          // 把列表里每个元素依次尾插进来
        }
    }
 
    void push_back(const T& val)
    {
        if (_finish == _endofstorage)
        {
            size_t oldsize = _finish - _start;
            size_t newcap = _endofstorage == _start ? 4 : 2 * (_endofstorage - _start);
            T* tmp = new T[newcap];
            for (size_t i = 0; i < oldsize; ++i)
                tmp[i] = _start[i];
            delete[] _start;
            _start = tmp;
            _finish = _start + oldsize;
            _endofstorage = _start + newcap;
        }
        *_finish = val;            // 在末尾位置构造
        ++_finish;
    }
 
    size_t size() const { return _finish - _start; }
 
private:
    iterator _start = nullptr;
    iterator _finish = nullptr;
    iterator _endofstorage = nullptr;
};
 
int main()
{
    MyVec<int> v{ 1, 2, 3, 4, 5 };   // 靠 initializer_list 构造完成
    MyVec<int> w = { 6, 7, 8 };      // 同理
    cout << v.size() << " " << w.size() << endl;   // 5 3
    return 0;
}

#include <iostream>
#include <vector>
#include <map>
using namespace std;
 
int main()
{
    auto a = 10;                     // 推导为 int
    auto b = 3.14;                   // 推导为 double
    auto c = "hello";                // 推导为 const char*
    auto d = { 1, 2, 3 };            // C++11：推导为 initializer_list<int>
 
    // 简化本来很长的类型名
    vector<int> v{ 1, 2, 3, 4, 5 };
    auto it = v.begin();             // 推导为 vector<int>::iterator
    cout << *it << endl;
 
    map<string, string> dict{ {"a", "1"}, {"b", "2"} };
    auto mit = dict.find("a");       // 推导为 map<...>::iterator，手写会非常啰嗦
    cout << mit->second << endl;
 
    // 结合范围 for（见下一节），写容器的遍历无比清爽
    for (const auto& e : v)
    {
        cout << e << " ";
    }
    cout << endl;
    return 0;
}

#include <iostream>
using namespace std;
 
int main()
{
    int x = 5;
    const int& rx = x;
 
    auto a = rx;                 // a 是 int（auto 剥掉了 const int&）-> 拷贝
    decltype(rx) b = x;          // b 是 const int&（decltype 保留原样）-> 引用
 
    cout << a << endl;
    cout << b << endl;
 
    // decltype 一个关键的括号规则：
    decltype(x)   c = x;         // 不带括号的变量名 x -> int
    decltype((x)) d = x;         // 带括号的表达式 (x) -> int& （括号让 x 成为左值表达式）
    // 也就是说 decltype((变量)) 的 `(变量)` 是一个"左值表达式"，推导为 int&
    cout << (&d == &x ? "d 是 x 的引用" : "不是引用") << endl;
    return 0;
}

#include <iostream>
using namespace std;
 
// 返回类型用 -> 放在参数后面，写成 decltype 表达式来精确推导
template<class T1, class T2>
auto add(T1 a, T2 b) -> decltype(a + b)
{
    return a + b;
}
 
int main()
{
    cout << add(1, 2) << endl;          // int
    cout << add(1.5, 2) << endl;        // double
    return 0;
}

#include <iostream>
#include <vector>
#include <string>
using namespace std;
 
int main()
{
    int arr[] = { 1, 2, 3, 4, 5 };
 
    // 把 arr 里每个元素拷贝进 e
    for (int e : arr)
    {
        cout << e << " ";
    }
    cout << endl;
 
    vector<string> names{ "苹果", "香蕉", "橙子" };
 
    // 只读遍历，用 const auto&，不拷贝
    for (const auto& n : names)
    {
        cout << n << " ";
    }
    cout << endl;
 
    // 想修改容器里的元素，用 auto& 引用遍历
    for (auto& e : arr)
    {
        e *= 2;                     // 直接把 arr 里的元素乘以 2
    }
    for (int e : arr)
    {
        cout << e << " ";
    }
    cout << endl;
    return 0;
}

for (auto it = begin(c); it != end(c); ++it)
{
    /* 循环体 */
}

#include <iostream>
#include <vector>
using namespace std;
 
int main()
{
    vector<int> v{ 1, 2, 3, 4, 5 };
 
#if 0   // 这段是错误示范：运行会崩溃/未定义
    for (auto& e : v)
    {
        if (e % 2 == 0)
            v.erase(v.begin() + (&e - &v[0]));   // 迭代器失效，UB
    }
#endif
 
    // 正确做法之一：去掉被删元素（erase-remove idiom）
    // 思路：先用 remove 把 "要删的" 挪到末尾，再 erase 统一删掉
    // （这里只演示思想，remove 需要 <algorithm>）
    // v.erase(remove_if(v.begin(), v.end(),
    //                   [](int x){ return x % 2 == 0; }), v.end());
 
    // 更朴素的正确做法：传统下标反向删（删"后面"的不影响前面下标）
    for (int i = (int)v.size() - 1; i >= 0; --i)
    {
        if (v[i] % 2 == 0)
            v.erase(v.begin() + i);   // 从后往前删，安全
    }
 
    for (int x : v) cout << x << " ";   // 1 3 5
    cout << endl;
    return 0;
}

#include <iostream>
#include <string>
#include <cmath>
using namespace std;
 
int main()
{
    // ---------- 常见左值：可以取地址 ----------
    int* p = new int(0);   // p 是左值
    int b = 1;             // b 是左值
    const int c = b;       // c 是 const 左值（不能赋值但可以取地址）
    *p = 10;               // *p 是左值
    string s("1111111");   // s 是左值
    s[0] = 'x';            // s[0] 是左值
    cout << &c << endl;                       // 可以取地址
    cout << (void*)&s[0] << endl;             // 可以取地址
 
    // 字符串字面量也是左值（它是 const char 数组，存在静态区，可取地址）
    cout << (const void*)"hello" << endl;     // 可取地址
 
    // ---------- 常见右值：不能取地址 ----------
    double x = 1.1, y = 2.2;
    10;                     // 字面量常量
    x + y;                  // 表达式求值结果
    fmin(x, y);             // 函数调用返回值（临时对象）
    string("11111");        // 匿名临时对象
 
    // 下面这些取地址都会编译报错：
    // cout << &10 << endl;
    // cout << &(x + y) << endl;
    // cout << &fmin(x, y) << endl;
    // cout << &string("11111") << endl;
    return 0;
}

template <class _Ty>
remove_reference_t<_Ty>&& move(_Ty&& _Arg)
{
    return static_cast<remove_reference_t<_Ty>&&>(_Arg);   // 无条件转成右值引用
}

#include <iostream>
#include <string>
#include <utility>   // std::move
using namespace std;
 
int main()
{
    int b = 1;
    int* p = &b;
    string s("1111111");
    double x = 1.1, y = 2.2;
 
    // ---------- 左值引用：给左值取别名 ----------
    int& r1 = b;          // OK：b 是左值
    string& r4 = s;       // OK：s 是左值
    char& r5 = s[0];      // OK：s[0] 是左值
 
    // ---------- 右值引用：给右值取别名 ----------
    int&& rr1 = 10;           // OK：10 是右值
    double&& rr2 = x + y;     // OK：x+y 的结果是右值
    string&& rr4 = string("11111");  // OK：匿名临时对象是右值
 
    // ---------- const 左值引用可以引用右值 ----------
    const int& rx = 10;         // OK
    const string& rx4 = string("11111"); // OK（且延长了临时对象生命周期）
 
    // ---------- 右值引用不能直接引用左值，但可以引用 move(左值) ----------
    // int&& rrx1 = b;                // 错误：b 是左值
    int&& rrx1 = move(b);            // OK：move 把 b 转成右值
    string&& rrx4 = move(s);         // OK
    string&& rrx5 = (string&&)s;     // 等价于直接强转
 
    // ---------- 验证第三条铁律：变量的表达式都是左值 ----------
    int&& rr = 5;           // rr 本身是右值引用，让它绑定右值 5
    // int&& rrx2 = rr;     // 错误！rr 这个"变量表达式"是左值，不能再被右值引用绑定
    int&& rrx3 = move(rr);  // 除非先 move 一下
 
    cout << rr1 << " " << rr2 << " " << rr4 << endl;
    return 0;
}

#include <iostream>
#include <string>
using namespace std;
 
int main()
{
    string s1 = "Test";
 
    // string&& r1 = s1;            // 错误：不能把右值引用绑定到左值 s1
    const string& r2 = s1 + s1;     // OK：const 左值引用延长临时对象的生存期
    // r2 += "Test";                // 错误：r2 是 const，不能修改
 
    string&& r3 = s1 + s1;          // OK：右值引用同样延长临时对象生存期
    r3 += "Test";                   // OK：r3 非 const，能修改
    cout << r3 << '\n';             // 输出 TestTestTest
 
    return 0;
}

#define _CRT_SECURE_NO_WARNINGS 1   // Windows/MSVC 下关闭 strcpy 等不安全告警，便于演示
#include <iostream>
#include <utility>          // std::swap / std::move
#include <cstring>
using namespace std;
 
namespace bit
{
    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((int)strlen(str)), _capacity(_size)
        {
            cout << "构造" << endl;
            _str = new char[_capacity + 1];
            strcpy(_str, str);
        }
 
        // 拷贝构造：逐个复制字符，深拷贝
        string(const string& s)
            : _str(nullptr)
        {
            cout << "拷贝构造" << endl;
            reserve(s._capacity);
            for (auto ch : s)
                push_back(ch);
        }
 
        // 移动构造：参数是右值引用，直接 swap 窃取资源，深拷贝为零
        string(string&& s)
        {
            cout << "移动构造" << endl;
            swap(s);               // 把 s 的资源全部"搬"到自己身上
        }
 
        // 拷贝赋值：深拷贝
        string& operator=(const string& s)
        {
            cout << "拷贝赋值" << endl;
            if (this != &s)
            {
                delete[] _str;
                _str = nullptr;
                _size = _capacity = 0;
                reserve(s._capacity);
                for (auto ch : s)
                    push_back(ch);
            }
            return *this;
        }
 
        // 移动赋值：参数是右值引用，swap 窃取资源
        string& operator=(string&& s)
        {
            cout << "移动赋值" << endl;
            swap(s);
            return *this;
        }
 
        void swap(string& s)
        {
            std::swap(_str, s._str);
            std::swap(_size, s._size);
            std::swap(_capacity, s._capacity);
        }
 
        ~string()
        {
            delete[] _str;
            _str = nullptr;
        }
 
        void reserve(size_t n)
        {
            if (n > _capacity)
            {
                char* tmp = new char[n + 1];
                if (_str)
                {
                    strcpy(tmp, _str);
                    delete[] _str;
                }
                _str = tmp;
                _capacity = n;
            }
        }
 
        void push_back(char ch)
        {
            if (_size >= _capacity)
            {
                size_t newcap = _capacity == 0 ? 4 : _capacity * 2;
                reserve(newcap);
            }
            _str[_size] = ch;
            ++_size;
            _str[_size] = '\0';
        }
 
        const char* c_str() const { return _str; }
 
    private:
        char* _str = nullptr;
        size_t _size = 0;
        size_t _capacity = 0;
    };
}
 
int main()
{
    bit::string s1("xxxxx");
 
    bit::string s2 = s1;                // 左值 -> 拷贝构造
    bit::string s3 = bit::string("yy"); // 右值临时对象 -> 移动构造
    bit::string s4 = move(s1);          // move 强制转右值 -> 移动构造
 
    cout << "s4 = " << s4.c_str() << endl;
    return 0;
}

#include <iostream>
#include <vector>
#include <utility>
using namespace std;
 
// 带打印的类，观察 vector 扩容时到底拷贝还是移动
class Item
{
public:
    Item(int n = 0) : _n(n) {}
    Item(const Item& src) { _n = src._n; cout << "拷贝构造\n"; }
    Item(Item&& src) noexcept { _n = src._n; cout << "移动构造(noexcept)\n"; }
    Item& operator=(const Item&) { cout << "拷贝赋值\n"; return *this; }
    Item& operator=(Item&&) noexcept { cout << "移动赋值(noexcept)\n"; return *this; }
private:
    int _n;
};
 
int main()
{
    // 一步步触发扩容：第 5 个 push_back 时容量翻倍，需要搬移已有 4 个元素
    vector<Item> v;
    v.reserve(1);        // 先留 1 个
    v.push_back(Item(1));
    v.reserve(8);        // 这次从 1 -> 8，搬移 1 个已有元素
    cout << "--- 扩容搬运发生在上面的 reserve 里 ---\n";
    return 0;
}

#include <iostream>
#include <utility>
using namespace std;
 
class Widget
{
public:
    // 安全的移动赋值：swap 一声令下，自赋值也安全
    Widget& operator=(Widget&& other) noexcept
    {
        cout << "移动赋值" << endl;
        swap(a, other.a);   // 交换后 this 拿走 old other 的 a，other 拿走 old this 的 a
        return *this;
    }
    int a = 0;
};
 
int main()
{
    Widget x;
    x = std::move(x);      // 自移动赋值，swap 方案安全不崩溃
    cout << x.a << endl;
    return 0;
}

#include <iostream>
#include <string>
using namespace std;
 
// 返回"函数内部创建的局部对象"是传值返回；过去拷贝代价大，现在自动走移动
string addStrings(const string& num1, const string& num2)
{
    string str;                          // 函数内部创建局部对象
    str = num1;                          // 这里演示真正的字符串相加逻辑，方便运行验证
    str.append(num2);
    return str;                          // 返回局部对象（以右值身份被接收）
}
 
int main()
{
    // 场景1：接收处直接构造，返回值是右值，触发移动构造，零深拷贝
    string ret = addStrings("11111", "2222");
    cout << ret << endl;
 
    // 场景2：接收处赋值，右值触发移动赋值
    string ret2;
    ret2 = addStrings("11111", "2222");
    cout << ret2 << endl;
    return 0;
}

#include <iostream>
#include <list>
#include <utility>
using namespace std;
 
// 下面假设 bit::string 已经有拷贝构造和移动构造（与上文一致）
// 为演示，这里用标准库 string 代替 bit::string，效果相同
void demo(list<string>& lt)
{
    string s1("11111111111111111111111111");
 
    lt.push_back(s1);                          // 左值 -> 拷贝构造
    lt.push_back(string("2222222222"));        // 右值临时对象 -> 移动构造
    lt.push_back("333333333333");              // const char* 转出的临时 -> 移动构造
    lt.push_back(move(s1));                    // move -> 移动构造
    cout << "前两个元素：" << lt.front();
    lt.pop_front();
    cout << " " << lt.front() << endl;
}
 
int main()
{
    list<string> lt;
    demo(lt);
    return 0;
}

template<class T>
void swap(T& a, T& b)
{
    T tmp = std::move(a);   // 搬走 a
    a = std::move(b);       // b 搬给 a
    b = std::move(tmp);     // tmp 里的旧 a 搬给 b
}

#include <iostream>
#include <utility>
using namespace std;
 
void f(int& x)        { cout << "左值引用   f(" << x << ")\n"; }
void f(const int& x)  { cout << "const左值引 f(" << x << ")\n"; }
void f(int&& x)       { cout << "右值引用   f(" << x << ")\n"; }
 
int main()
{
    int i = 1;
    const int ci = 2;
 
    f(i);                // 左值 -> f(int&)
    f(ci);               // const左值 -> f(const int&)
    f(3);                // 右值 -> f(int&&)；若没有右值重载则回退到 f(const int&)
    f(std::move(i));     // move 后成右值 -> f(int&&)
 
    // 第三条铁律再现：右值引用变量表达式是左值
    int&& x = 1;
    f(x);                // x 是左值 -> f(int&)
    f(std::move(x));     // 再 move 一次 -> f(int&&)
    return 0;
}

#include <iostream>
using namespace std;
 
// f1：T& 经过折叠，总是实例化成左值引用版本
template<class T>
void f1(T& x) {}
 
// f2：T&& 经过折叠，可以既是左值引用版本，也可以是右值引用版本
template<class T>
void f2(T&& x) {}
 
int main()
{
    typedef int& lref;
    typedef int&& rref;
    int n = 0;
 
    lref& r1 = n;      // 折叠后类型是 int&  -> 左值引用
    lref&& r2 = n;     // 折叠后类型是 int&  -> 左值引用
    rref& r3 = n;      // 折叠后类型是 int&  -> 左值引用
    rref&& r4 = 1;     // 折叠后类型是 int&& -> 右值引用
 
    // 用显式模板实参来强制观察 f1/f2 各自折叠出的形态
    f1<int>(n);                 // 实例化成 f1(int&)
    // f1<int>(0);              // 错误：int 不是左值，绑不到 int&
    f1<int&>(n);                // int& 实例化成 f1(int&)：int& 本身折叠
    f1<int&&>(n);               // int&& 传入，T& 形参加上 int&& 折叠为 int&：也绑最近对的 n
 
    f2<int>(0);                 // 右值：f2(int&&)（T=int，无折叠）
    // f2<int>(n);              // 错误：等 T=int 且形参 int&&，右值引用绑不了左值 n
    f2<int&>(n);                // 左值：int& && 折叠成 int& -> f2(int&)
    f2<int&&>(0);               // 右值：int&& && 折叠成 int&& -> f2(int&&)
    // f2<int&&>(n);            // 错误：int&& 形参绑不了左值 n
    return 0;
}

#include <iostream>
#include <utility>
using namespace std;
 
void Fun(int& x)        { cout << "左值引用\n"; }
void Fun(const int& x)  { cout << "const左值引用\n"; }
void Fun(int&& x)       { cout << "右值引用\n"; }
void Fun(const int&& x) { cout << "const右值引用\n"; }
 
// 不使用 forward 的"伪转发"（不完美）
template<class T>
void NotPerfect(T&& t)
{
    Fun(t);             // t 是左值，永远命中左值版本，右值身份丢失！
}
 
// 使用 forward 的完美转发
template<class T>
void Perfect(T&& t)
{
    Fun(forward<T>(t)); // forward<T> 依据 T 恢复 t 原来的左右值身份
}
 
int main()
{
    int a = 1;
    const int b = 8;
 
    cout << "---- 不完美转发 ----\n";
    NotPerfect(10);      // 期望右值，结果命中 左值引用
    NotPerfect(a);       // 左值 -> 左值引用
 
    cout << "---- 完美转发 ----\n";
    Perfect(10);         // 右值 -> 右值引用
    Perfect(a);          // 左值 -> 左值引用
    Perfect(move(a));    // 右值 -> 右值引用
    Perfect(b);          // const左值 -> const左值引用
    Perfect(move(b));    // const右值 -> const右值引用
    return 0;
}

template <class _Ty>
_Ty&& forward(remove_reference_t<_Ty>& _Arg) noexcept
{
    return static_cast<_Ty&&>(_Arg);
}

template <class... Args> void Func(Args... args) {}            // 按值
template <class... Args> void Func(Args&... args) {}           // 左值引用
template <class... Args> void Func(Args&&... args) {}          // 转发引用（最常用）

#include <iostream>
#include <string>
using namespace std;
 
template <class... Args>
void Print(Args&&... args)
{
    cout << sizeof...(args) << endl;   // 打印参数包中有几个参数
}
 
int main()
{
    double x = 2.2;
    Print();                          // 0 个参数
    Print(1);                         // 1 个
    Print(1, string("xxxxx"));        // 2 个
    Print(1.1, string("xxxxx"), x);   // 3 个
    return 0;
}

#include <iostream>
using namespace std;
 
// 这条路走不通：不能用下标访问参数包里的元素
// template<class... Args>
// void Print(Args... args)
// {
//     for (size_t i = 0; i < sizeof...(args); ++i)
//         cout << args[i];      // 错误：args 是参数包，不是数组
// }
int main(){ return 0; }

#include <iostream>
#include <string>
using namespace std;
 
// 递归的终止条件：参数包为 0 个参数时匹配到这个无参版本
void ShowList()
{
    cout << endl;
}
 
// 每次都"取第一个参数 + 剩下的参数包递归"
template<class T, class... Args>
void ShowList(T x, Args... args)
{
    cout << x << " ";
    ShowList(args...);        // 参数包 args... 继续递归，一次吃掉第一个
}
 
// 入口
template<class... Args>
void Print(Args... args)
{
    ShowList(args...);        // 包扩展：把 args 依次展开传给 ShowList
}
 
int main()
{
    Print(1, string("xxxxx"), 2.2);
    // 输出：1 xxxxx 2.2
    return 0;
}

#include <iostream>
#include <string>
using namespace std;
 
// 对单个参数做点事，再转发出去
template<class T>
const T& GetArg(const T& x)
{
    cout << x << " ";
    return x;
}
 
template<class... Args>
void Arguments(Args... args) {}   // 收集全部展开后的参数
 
template<class... Args>
void Print(Args... args)
{
    // 包扩展模式：对包中每个元素都调用 GetArg(x)，产出 GetArg(x_1), GetArg(x_2), ...
    Arguments(GetArg(args)...);
}
 
int main()
{
    Print(1, string("xxxxx"), 2.2);
    // 编译器大致把它展开成：Arguments(GetArg(1), GetArg(string("xxxxx")), GetArg(2.2))
    return 0;
}

#include <iostream>
using namespace std;
 
// 终止：空包的和是 0
long long Sum()
{
    return 0;
}
 
// 递归：取第一个 + 对剩余参数包求和
template<class T, class... Args>
long long Sum(T first, Args... rest)
{
    return first + Sum(rest...);     // 第一个 加 剩余包的和
}
 
int main()
{
    cout << Sum(1, 2, 3, 4, 5) << endl;                 // 15
    cout << Sum(1, 2.5, 3) << endl;                      // 6.5
    cout << Sum() << endl;                               // 0
    return 0;
}

template<class... Args> void emplace_back(Args&&... args);
template<class... Args> iterator emplace(const_iterator position, Args&&... args);

// push_back：先构造临时 T，再把临时 T（经过移动/拷贝）放入容器
lt.push_back(bit::string("1111"));
 
// emplace_back：直接从 "1111" 这个 const char* 构造出容器里的 T，少一次移动
lt.emplace_back("1111");

#include <iostream>
#include <list>
#include <string>
#include <utility>
using namespace std;
 
int main()
{
    list<pair<string, int>> lt;
 
    pair<string, int> kv("苹果", 1);
    lt.push_back(kv);                  // 用已存在的 kv：pair 拷贝构造进节点
    // 成本：pair 的拷贝构造（里面 string 深拷贝）
 
    lt.push_back(move(kv));            // pair 移动构造进节点
    // 成本：pair 的移动构造（里面 string 移动，O(1)）
 
    lt.push_back({ "香蕉", 2 });       // {} 先造 pair 临时对象，再移动/拷贝进节点
    // 成本：构造临时 pair + 移动/拷贝进节点 + 析构临时 pair
 
    lt.emplace_back("橙子", 3);        // 直接把 "橙子"、3 这两个参数塞进节点，在原地构造 pair
    // 成本：只有一次原地构造 pair（内部 string 直接构造），零移动零拷贝零临时
 
    cout << "元素个数：" << lt.size() << endl;
    return 0;
}

namespace bit
{
    // 链表节点：新增一个接收参数包的构造（用于 emplace 直接构造 T）
    template<class T>
    struct ListNode
    {
        ListNode<T>* _next;
        ListNode<T>* _prev;
        T _data;
 
        // 关键：参数包 + 完美转发，直接构造 _data（对应 T 的某个构造函数）
        template<class... Args>
        ListNode(Args&&... args)
            : _next(nullptr)
            , _prev(nullptr)
            , _data(std::forward<Args>(args)...)
        {}
    };
 
    // 链表类里（截取最关键的两段）
    template<class T>
    class list
    {
        typedef ListNode<T> Node;
    public:
        // emplace_back：把参数包继续 forward 进 insert
        template<class... Args>
        void emplace_back(Args&&... args)
        {
            insert(end(), std::forward<Args>(args)...);
        }
 
        // insert 的模板版本：用参数包直接构造节点
        template<class... Args>
        iterator insert(iterator pos, Args&&... args)
        {
            Node* cur = pos._node;
            Node* prev = cur->_prev;
            Node* newnode = new Node(std::forward<Args>(args)...); // 用参数包直接构造节点
            prev->_next = newnode;          // 链接指针：prev newnode cur
            newnode->_prev = prev;
            newnode->_next = cur;
            cur->_prev = newnode;
            return iterator(newnode);
        }
    private:
        Node* _head;
    };
}

#include <iostream>
#include <string>
using namespace std;
 
class Person
{
public:
    Person(const char* name = "", int age = 0) : _name(name), _age(age)
    {}
 
    // 一旦写了拷贝构造，编译器默认就不再生成移动构造
    Person(const Person& p) : _name(p._name), _age(p._age)
    {}
 
    // 用 default 显式让编译器生成默认移动构造（逐成员移动：string 自身会移动）
    Person(Person&& p) = default;
 
    // 如果想去掉拷贝赋值，一个 delete 就搞定：
    // Person& operator=(const Person& p) = delete;
 
private:
    std::string _name;   // 成员里有 string，移动它会真的走 string 的移动构造
    int _age;
};
 
int main()
{
    Person s1("Alice", 20);
    Person s2 = s1;            // 拷贝构造
    Person s3 = std::move(s1); // 移动构造（default 生成，逐成员移动，_name 走 string 移动）
    return 0;
}

#include <iostream>
using namespace std;
 
void f(double)      { cout << "double 版本\n"; }
void f(int) = delete;   // int 不准直接进来
 
int main()
{
    f(3.14);        // double -> f(double)
    // f(3);        // 错误：f(int) 被删除了，int 3 想隐式转 double 的那条路也被挡住
    f(static_cast<double>(3));  // 显式转换后才放行
    return 0;
}

unique_ptr(const unique_ptr&) = delete;
unique_ptr& operator=(const unique_ptr&) = delete;

#include <iostream>
using namespace std;
 
class Base
{
public:
    virtual void draw() { cout << "Base::draw\n"; }   // 基类虚函数
};
 
class Derived : public Base
{
public:
    void draw() override { cout << "Derived::draw\n"; }  // override：编译器核对签名确实覆盖了 draw()
    virtual void seal() final { cout << "sealed\n"; }    // final 虚函数：派生类不能再覆盖
};
 
class Leaf final : public Derived   // final 类，不能再被继承
{
public:
    void draw() override { cout << "Leaf::draw\n"; }
    // void seal() override {}        // 错误：Base seal 在 Derived 里被标 final，不可再覆盖
};
 
// class GrandChild : public Leaf {};  // 错误：Leaf 是 final 类，不能再被继承
 
int main()
{
    Base* p = new Derived();
    p->draw();                        // Derived::draw（多态）
    delete p;
    return 0;
}

#include <iostream>
#include <string>
using namespace std;
 
class Foo
{
public:
    // _count 和 _name 有"就地"缺省值；若构造时不进初始化列表，就用它们
    Foo() {}                                   // _count=0, _name="unknown"
    Foo(int c) : _count(c) {}                  // _count=c, _name="unknown"
    explicit Foo(int c, const char* n)         // 两个都显式指定
        : _count(c), _name(n)
    {}
 
    void show() const { cout << _count << " " << _name << endl; }
 
private:
    int    _count = 0;          // C++11：声明时给缺省值
    string _name = "unknown";   // 同上
};
 
int main()
{
    Foo a;
    a.show();                     // 0 unknown
    Foo b(5);
    b.show();                     // 5 unknown
    Foo c(1, "hello");
    c.show();                     // 1 hello
    return 0;
}

#include <iostream>
using namespace std;
 
void f(int)        { cout << "f(int)\n"; }
void f(void*)      { cout << "f(void*)\n"; }
 
int main()
{
    int* p = nullptr;     // 明确：p 是空指针
    // int n = nullptr;   // 错误：nullptr 不能隐式转 int
 
    f(nullptr);    // 精确命中 f(void*)，不再有歧义
    // f(NULL);     // 若 NULL 是 0，会命中 f(int)，与预期不符
    return 0;
}

#include <iostream>
using namespace std;
 
enum class Color : char   // 指定底层类型为 char（C++11 支持）
{
    Red,    // 0
    Green,  // 1
    Blue    // 2
};
 
enum OldColor { ORed, OGreen };   // 传统 enum：值会泄漏到外层作用域
 
int main()
{
    Color c = Color::Green;         // 必须带作用域 Color::
    // int i = c;                   // 错误：enum class 不隐式转 int
    int i = static_cast<int>(c);    // 需要显式转换
    cout << i << endl;
 
    int x = ORed;                   // 传统 enum 就能隐式转 int
    cout << x << endl;
 
    // switch 里用 enum class 更安全（编译器会警告未处理的情形）
    switch (c)
    {
    case Color::Red:   cout << "red\n";   break;
    case Color::Green: cout << "green\n"; break;
    case Color::Blue:  cout << "blue\n";  break;
    }
    return 0;
}

[捕捉列表](参数列表) -> 返回值类型 { 函数体 }

#include <iostream>
using namespace std;
 
int main()
{
    // 一个最简单的 lambda：两个 int 相加
    auto add1 = [](int x, int y)->int { return x + y; };
    cout << add1(1, 2) << endl;           // 3
 
    // 捕捉列表为空也不能省；参数可以省；返回值可省略；函数体不能省
    auto func1 = []
    {
        cout << "hello" << endl;          // 没有返回值
        return 0;                          // 返回 0，编译器推导返回 int
    };
    func1();
 
    int a = 0, b = 1;
 
    // lambda 也可以接收引用参数来修改外部变量（这里没用到捕捉列表）
    auto swap1 = [](int& x, int& y)
    {
        int tmp = x;
        x = y;
        y = tmp;
    };
    swap1(a, b);
    cout << a << ":" << b << endl;        // 1:0
    return 0;
}

#include <iostream>
using namespace std;
 
int main()
{
    // 无捕获 lambda 可以转成函数指针
    void (*fp)(int) = [](int x) { cout << x << " "; };
    fp(42);                      // 42
 
    // C 风格 API 需要函数指针回调时，无捕获 lambda 能直接喂进去
    int (*cmp)(int, int) = [](int a, int b) { return a - b; };
    cout << cmp(5, 3) << endl;   // 2
 
    // 一旦捕获了外部变量，就不能转函数指针了：
    // int base = 10;
    // void (*fp2)(int) = [=](int x) { cout << x + base; };  // 错误
    return 0;
}

#include <iostream>
using namespace std;
 
int g = 0;   // 全局变量：不需要捕捉，lambda 里可直接用
 
int main()
{
    int a = 0, b = 1, c = 2, d = 3;
 
    // 显式捕捉：a 值捕捉，b 引用捕捉
    auto func1 = [a, &b]
    {
        // a++;            // 错误：值捕捉的 a 默认是 const，不能改
        b++;               // 引用捕捉可以修改外部 b
        int ret = a + b;
        return ret;
    };
    cout << func1() << endl;      // 0 + 2 = 2
 
    // 隐式值捕捉：用到哪些就按值捕捉哪些
    auto func2 = [=]
    {
        int ret = a + b + c;      // a、b、c 都被自动值捕捉
        return ret;
    };
    cout << func2() << endl;
 
    // 隐式引用捕捉：用到的外层变量都按引用捕捉，可修改
    auto func3 = [&]
    {
        a++; b++; c++; d++;       // 直接改外层
    };
    func3();
    cout << a << " " << b << " " << c << " " << d << endl;   // 1 2 3 4
 
    // 混合捕捉：除 a、b 外都按引用，a、b 按值
    auto func4 = [&, a, b]
    {
        // a++; b++;      // 错误：a、b 是值捕捉（const）
        c++; d++;          // OK：其余按引用捕捉
    };
    func4();
 
    // mutable：让值捕捉的变量可改，但只改拷贝，不影响外边
    auto func7 = [=]() mutable
    {
        a++;               // 现在能在函数体里改了（改的是副本）
        b++;
        return a + b;
    };
    cout << func7() << endl;     // 自增副本后返回
    cout << a << " " << b << endl;  // 外部 a、b 不受影响
    return 0;
}

#include <iostream>
#include <functional>
using namespace std;
 
std::function<int()> make()
{
    int local = 100;
    return [&]{ return local; };   // 危险：local 是栈上局部，函数返回就亡了
}
// make() 返回后，local 已销毁，这个 lambda 再调用会悬空
 
int main()
{
    // 下面这行一调用就会用到悬空引用（行为未定义，可能崩溃/输出乱值）
    // auto f = make();
    // cout << f() << endl;
 
    // 治本一：按值捕捉，把值拷进 lambda
    std::function<int()> ok = [x = 100]{ return x; };   // (初始化捕获，C++14)
    std::function<int()> ok2 = [y = 42]{ return y; };   // C++14 语法
    cout << ok() << " " << ok2() << endl;
 
    // 治本二：明确对象的生命周期比 lambda 长（如全局、静态、或被长存对象持有）
    return 0;
}

#include <iostream>
using namespace std;
 
// 手写的一个"仿函数类"：重载 operator()，内部存一个成员 _rate
class Rate
{
public:
    Rate(double r) : _rate(r) {}
 
    double operator()(double money, int year)   // lambda 的函数体就对应这里
    {
        return money * _rate * year;
    }
 
private:
    double _rate;      // lambda 的"值捕捉变量"就对应这里的成员
};
 
int main()
{
    double rate = 0.49;
 
    // 用 lambda 实现同样的事情：rate 是值捕捉
    auto r2 = [rate](double money, int year)
    {
        return money * rate * year;
    };
 
    // 手写仿函数
    Rate r1(rate);
 
    cout << r1(10000, 2) << endl;   // 9800
    cout << r2(10000, 2) << endl;   // 9800
    return 0;
}

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>   // sort
using namespace std;
 
struct Goods
{
    string _name;
    double _price;
    int _evaluate;
 
    Goods(const char* n, double p, int e) : _name(n), _price(p), _evaluate(e) {}
};
 
int main()
{
    vector<Goods> v = {
        { "苹果", 2.1, 5 },
        { "香蕉", 3.0, 4 },
        { "橙子", 2.2, 3 },
        { "菠萝", 1.5, 4 }
    };
 
    // 以前要为此定义一个仿函数类或函数指针，现在一行 lambda 就够了
    sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2)
    {
        return g1._price < g2._price;    // 按价格升序
    });
 
    sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2)
    {
        return g1._evaluate > g2._evaluate;   // 按评价降序
    });
 
    for (const auto& g : v)
        cout << g._name << " " << g._price << " " << g._evaluate << endl;
    return 0;
}

std::function<返回类型(参数类型列表)> 变量 = 某个可调用对象;

#include <iostream>
#include <functional>
using namespace std;
 
// 普通函数
int f(int a, int b) { return a + b; }
 
// 仿函数
struct Functor
{
    int operator()(int a, int b) { return a + b; }
};
 
// 带静态和普通成员函数的类
class Plus
{
public:
    Plus(int n = 10) : _n(n) {}
    static int plusi(int a, int b) { return a + b; }          // 静态成员函数
    double plusd(double a, double b) { return (a + b) * _n; } // 普通成员函数
private:
    int _n;
};
 
int main()
{
    using BinOp = function<int(int, int)>;   // 统一的类型别名
 
    BinOp f1 = f;                 // 存函数指针
    BinOp f2 = Functor();         // 存仿函数
    BinOp f3 = [](int a, int b) { return a + b; };  // 存 lambda
    cout << f1(1, 1) << " " << f2(1, 1) << " " << f3(1, 1) << endl;  // 2 2 2
 
    // 包装静态成员函数：需要带类域 + 取地址
    BinOp f4 = &Plus::plusi;
    cout << f4(1, 1) << endl;      // 2
 
    // 包装普通成员函数：成员函数隐含一个 this 参数
    // 所以签名里第一个参数要写成 Plus* / Plus&（对象自身）
    function<double(Plus, double, double)> f5 = &Plus::plusd;
    Plus pd;
    cout << f5(pd, 1.1, 1.1) << endl;      // (1.1+1.1)*10 = 22
    return 0;
}