// 一個(gè)參數(shù)
void Print(int x) { cout << x << endl; }
// 兩個(gè)參數(shù)——再寫(xiě)一個(gè)
void Print(int x, string y) { cout << x << " " << y << endl; }
// 三個(gè)參數(shù)——再再寫(xiě)一個(gè)
void Print(int x, string y, double z) {
    cout << x << " " << y << " " << z << endl;
}
// ... 四個(gè)？五個(gè)？到底寫(xiě)到什么時(shí)候？

template <class ...Args>
void Print(Args... args) {
    // args 是一個(gè)"參數(shù)包"（parameter pack）
    // 包含了你傳進(jìn)來(lái)的所有參數(shù)
}

template <class ...Args>
void Print(Args&&... args) {
    cout << "參數(shù)個(gè)數(shù)：" << sizeof...(args) << endl;
}
int main() {
    Print();          // 輸出：參數(shù)個(gè)數(shù)：0
    Print(1);         // 輸出：參數(shù)個(gè)數(shù)：1
    Print(1, "hello"); // 輸出：參數(shù)個(gè)數(shù)：2
    Print(1, 2.5, "hello"); // 輸出：參數(shù)個(gè)數(shù)：3
}

template <class ...Args>
void Print(Args&&... args) {
    // 錯(cuò)誤示范！不支持下標(biāo)訪問(wèn)
    for (size_t i = 0; i < sizeof...(args); i++) {
        cout << args[i] << " ";  // ? 編譯錯(cuò)誤！
    }
    cout << endl;
}

template <class ...Args>
void Print(Args&&... args) {
    // 錯(cuò)誤示范！范圍for不支持參數(shù)包展開(kāi)
    for (auto&& e : args...) {   // ? 同樣編譯不通過(guò)
        cout << e << " ";
    }
    cout << endl;
}

// 遞歸終止函數(shù)——當(dāng)參數(shù)包為空時(shí)調(diào)用
void ShowList() {
    cout << endl;  // 打印最后一個(gè)換行，遞歸結(jié)束
}
// 遞歸展開(kāi)函數(shù)——每次取出第一個(gè)參數(shù)x，剩下的繼續(xù)展開(kāi)
template <class T, class ...Args>
void ShowList(T&& x, Args&&... args) {
    cout << x << " ";      // 處理當(dāng)前層的第一個(gè)參數(shù)
    ShowList(args...);     // 剩下的參數(shù)包遞歸傳給下一層
}
// 對(duì)外接口——直接轉(zhuǎn)發(fā)給實(shí)際的處理函數(shù)
template <class ...Args>
void Print(Args&&... args) {
    ShowList(args...);
}
int main() {
    Print(1, 2.5, string("hello"), 'A');
    // 輸出：1 2.5 hello A
    return 0;
}

調(diào)用 Print(1, 2.5, "hello", 'A')
    ↓
調(diào)用 ShowList(1, 2.5, "hello", 'A')
    x = 1, 打印 "1 "
    args = (2.5, "hello", 'A')
    ↓ 遞歸
調(diào)用 ShowList(2.5, "hello", 'A')
    x = 2.5, 打印 "2.5 "
    args = ("hello", 'A')
    ↓ 遞歸
調(diào)用 ShowList("hello", 'A')
    x = "hello", 打印 "hello "
    args = ('A')
    ↓ 遞歸
調(diào)用 ShowList('A')
    x = 'A', 打印 "A "
    args = ()  ← 空參數(shù)包
    ↓ 遞歸
調(diào)用 ShowList()  ← 匹配到終止函數(shù)，打印換行

template <class T>
int GetArg(const T& x) {
    cout << x << " ";
    return 0;
}
// 這個(gè)函數(shù)什么都不做，只是用來(lái)"容納"逗號(hào)表達(dá)式展開(kāi)的結(jié)果
template <class ...Args>
void Arguments(Args... args) {}
template <class ...Args>
void Print(Args... args) {
    // 核心魔法在這一行！
    Arguments(GetArg(args)...);
}
int main() {
    double x = 2.2;
    Print();
    Print(1);
    Print(1, string("xxxxx"));
    Print(1.1, string("xxxxx"), x);
    return 0;
}

Arguments(GetArg(args)...);

Arguments(GetArg(1), GetArg(string("hello")), GetArg(2.2));

template<class T>
struct list_node {
    T _data;
    list_node<T>* _next;
    list_node<T>* _prev;
    list_node() = default;
    // 可變參數(shù) + 萬(wàn)能引用 + 完美轉(zhuǎn)發(fā) → 三合一
    template <class... Args>
    list_node(Args&&... args)
        : _next(nullptr)
        , _prev(nullptr)
        , _data(std::forward<Args>(args)...)   // 注意這里...
    {}
};

_data(std::forward<T1>(arg1), std::forward<T2>(arg2), std::forward<T3>(arg3))

template<class T>
class list {
public:
    // 左值引用版本：深拷貝
    void push_back(const T& x) {
        insert(end(), x);
    }
    // 右值引用版本：移動(dòng)
    void push_back(T&& x) {
        insert(end(), forward<T>(x));
    }
};

jys::list<jys::string> lt;
jys::string s1("111111111111");
lt.push_back(s1);                  // s1是左值 → 調(diào)用 const T& 版本
lt.push_back(move(s1));            // move后是右值 → 調(diào)用 T&& 版本
lt.push_back("111111111111");      // 字面量是右值 → 調(diào)用 T&& 版本，但需要隱式構(gòu)造string

template<class T>
class list {
public:
    // emplace_back 接受任意參數(shù)，直接轉(zhuǎn)發(fā)給節(jié)點(diǎn)構(gòu)造函數(shù)
    template <class... Args>
    void emplace_back(Args&&... args) {
        insert(end(), std::forward<Args>(args)...);
    }
    template <class... Args>
    iterator insert(iterator pos, Args&&... args) {
        Node* cur = pos._node;
        Node* prev = cur->_prev;
        // new Node時(shí)直接把參數(shù)轉(zhuǎn)發(fā)給T的構(gòu)造函數(shù)，在堆上原地構(gòu)造
        Node* newnode = new Node(std::forward<Args>(args)...);
        prev->_next = newnode;
        newnode->_prev = prev;
        newnode->_next = cur;
        cur->_prev = newnode;
        return iterator(newnode);
    }
};

int main() {
    list<jys::string> lt;
    jys::string s1("111111111111");
    jys::string s2("222222222222");
    // 場(chǎng)景1：傳左值
    lt.push_back(s1);       // const T& → 調(diào)string的拷貝構(gòu)造
    lt.emplace_back(s1);    // 同樣傳左值 → 也調(diào)拷貝構(gòu)造，和push_back沒(méi)區(qū)別
    // 場(chǎng)景2：傳右值
    lt.push_back(move(s2));      // T&& → 調(diào)string的移動(dòng)構(gòu)造
    lt.emplace_back(move(s1));   // 同樣傳右值 → 也調(diào)移動(dòng)構(gòu)造，和push_back沒(méi)區(qū)別
    // 場(chǎng)景3：直接傳構(gòu)造參數(shù)——這是emplace_back真正的舞臺(tái)！
    lt.emplace_back("111111111111");    // 直接把const char*傳給節(jié)點(diǎn)的string構(gòu)造
                                        // 在節(jié)點(diǎn)內(nèi)部原地構(gòu)造，一次構(gòu)造搞定！
    cout << "***********************" << endl;
    lt.push_back("111111111111");       // 先用const char*構(gòu)造臨時(shí)string
                                        // 再把臨時(shí)string移動(dòng)到節(jié)點(diǎn)中
                                        // 兩步操作：構(gòu)造+移動(dòng)（有可能被優(yōu)化掉）
    return 0;
}

int main() {
    jys::list<pair<jys::string, int>> lt1;
    // ===== push_back 方式 =====
    pair<jys::string, int> kv("蘋果", 1);
    lt1.push_back(kv);          // pair的拷貝構(gòu)造 → 內(nèi)部string的拷貝構(gòu)造
    cout << "***********************" << endl;
    lt1.push_back(move(kv));    // pair的移動(dòng)構(gòu)造 → 內(nèi)部string的移動(dòng)構(gòu)造
    cout << "***********************" << endl;
    lt1.push_back({"蘋果", 1});  // 先構(gòu)造臨時(shí)pair → 再移動(dòng)到節(jié)點(diǎn)
    cout << "***********************" << endl;
    // ===== emplace_back 方式 =====
    // 直接傳兩個(gè)參數(shù)給pair的構(gòu)造函數(shù)，在節(jié)點(diǎn)內(nèi)部原地構(gòu)造！
    lt1.emplace_back("蘋果", 1);
    // 注意：不能寫(xiě)成 emplace_back({"蘋果", 1})，因?yàn)閧}不會(huì)被推導(dǎo)為pair
    cout << "***********************" << endl;
    return 0;
}

struct Goods {
    string _name;
    double _price;
    int _evaluate;
    Goods(const char* str, double price, int evaluate)
        : _name(str), _price(price), _evaluate(evaluate) {}
};
// 按價(jià)格升序比較——得寫(xiě)一個(gè)完整的仿函數(shù)類
struct ComparePriceLess {
    bool operator()(const Goods& gl, const Goods& gr) {
        return gl._price < gr._price;
    }
};
// 按價(jià)格降序比較——又得寫(xiě)一個(gè)
struct ComparePriceGreater {
    bool operator()(const Goods& gl, const Goods& gr) {
        return gl._price > gr._price;
    }
};
int main() {
    vector<Goods> v = {
        {"蘋果", 2.1, 5}, {"香蕉", 3, 4},
        {"橙子", 2.2, 3}, {"菠蘿", 1.5, 4}
    };
    sort(v.begin(), v.end(), ComparePriceLess());
    sort(v.begin(), v.end(), ComparePriceGreater());
    return 0;
}

int main() {
    vector<Goods> v = {
        {"蘋果", 2.1, 5}, {"香蕉", 3, 4},
        {"橙子", 2.2, 3}, {"菠蘿", 1.5, 4}
    };
    // 價(jià)格升序——比較邏輯就寫(xiě)在調(diào)用處！
    sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
        return g1._price < g2._price;
    });
    // 價(jià)格降序——改一個(gè)符號(hào)就行
    sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
        return g1._price > g2._price;
    });
    // 按評(píng)價(jià)排序——換個(gè)成員變量就行
    sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
        return g1._evaluate < g2._evaluate;
    });
    return 0;
}

[捕獲列表] (參數(shù)列表) mutable -> 返回值類型 { 函數(shù)體 }

auto func1 = [] {
    cout << "hello jys" << endl;
    return 0;
};
func1();  // 調(diào)用

auto add1 = [](int x, int y) -> int { return x + y; };
cout << add1(1, 2) << endl;  // 輸出: 3
// -> int 可以省略，編譯器從 return 語(yǔ)句自動(dòng)推導(dǎo)返回值類型
auto add2 = [](int x, int y) { return x + y; };
cout << add2(3, 4) << endl;  // 輸出: 7

int a = 0, b = 1, c = 2;
auto func = [a, b](int x) mutable {
    a++;   // 修改的是a的副本，外部a不變
    b++;   // 修改的是b的副本，外部b不變
    return a + b + x;
};
cout << func(1) << endl;   // 內(nèi)部 a=1, b=2, x=1 → 輸出4
cout << "外部 a=" << a << endl;  // 輸出：外部 a=0 （沒(méi)變?。?/pre>

int a = 0, b = 1;
auto func = [&a, &b] {
    a++;   // 修改的就是外部a
    b++;   // 修改的就是外部b
};
func();
cout << "a=" << a << ", b=" << b << endl;  // 輸出：a=1, b=2

int a = 0, b = 1, c = 2, d = 3;
// [=] 以值的方式捕獲所有用到的外部變量
auto func1 = [=] {
    return a + b + c;  // a, b, c 都以值方式捕獲
};
// [&] 以引用的方式捕獲所有用到的外部變量
auto func2 = [&] {
    a++; c++;  // a, c 都以引用方式捕獲，修改直接影響外部
};
func2();
cout << "a=" << a << ", c=" << c << endl;  // 輸出：a=1, c=3

int a = 0, b = 1, c = 2, d = 3;
// 大部分值捕獲，但 c 和 d 用引用捕獲
auto func4 = [=, &c, &d] {
    // a++; b++;  // ? 值捕獲，不能修改（除非加mutable）
    c++;          // ? 引用捕獲，可以修改
    d++;          // ? 引用捕獲，可以修改
    return a + b + c + d;
};
func4();
cout << a << " " << b << " " << c << " " << d << endl;
// 輸出：0 1 3 4（c和d被修改了）
// 大部分引用捕獲，但 a 和 b 用值捕獲
auto func5 = [&, a, b] {
    // a++;  // ? 值捕獲，不能修改
    c++;      // ? 引用捕獲
    d++;      // ? 引用捕獲
};

int y = 0;  // 全局變量
auto func = [] {
    y++;  // 直接訪問(wèn)，不需要捕獲
};

auto func = [](int x, int y) { return x + y; };
cout << typeid(func).name() << endl;  // 輸出一串編譯器生成的類名

// 你看不到這個(gè)類，但編譯器在背后就是這么干的
class __lambda_unique_id {
public:
    // []的捕獲內(nèi)容對(duì)應(yīng)這里的成員變量
    // ()的參數(shù)列表對(duì)應(yīng) operator() 的形參
    // {}的函數(shù)體對(duì)應(yīng) operator() 的函數(shù)體
    int operator()(int x, int y) const {
        return x + y;
    }
};

double rate = 0.49;
// lambda 版本
auto r2 = [rate](double money, int year) {
    return money * rate * year;
};
// 等價(jià)的仿函數(shù)版本
class Rate {
public:
    Rate(double rate) : _rate(rate) {}
    double operator()(double money, int year) {
        return money * _rate * year;
    }
private:
    double _rate;
};
Rate r1(rate);
// 兩者用法完全一樣
cout << r1(10000, 2) << endl;  // 仿函數(shù)
cout << r2(10000, 2) << endl;  // lambda

#include <string>
#include <iostream>
using namespace std;
namespace jys {
    class string {
        // ... (自定義string類的實(shí)現(xiàn))
    };
}
class Person {
public:
    Person(const char* name = "張三", int age = 1)
        : _name(name), _age(age) {}
    // 我自定義了拷貝構(gòu)造和移動(dòng)構(gòu)造，但還想讓編譯器生成默認(rèn)版本
    Person(Person&& p) = default;        // 編譯器，幫我生成默認(rèn)移動(dòng)構(gòu)造
	//Person(const Person& p) = delete;限制默認(rèn)函數(shù)的生成
    // 析構(gòu)函數(shù)也用默認(rèn)的
    ~Person() = default;
private:
    jys::string _name;
    int _age;
};
int main() {
    Person s1;
    Person s2 = s1;               // 調(diào)用默認(rèn)拷貝構(gòu)造（逐成員拷貝）
    Person s3 = std::move(s1);    // 調(diào)用默認(rèn)移動(dòng)構(gòu)造（逐成員移動(dòng)）
    return 0;
}

#include <functional>
#include <iostream>
#include <map>
#include <string>
using namespace std;
int f(int a, int b) {
    return a + b;
}
struct Functor {
    int operator()(int a, int b) {
        return a + b;
    }
};
int main() {
    // function<int(int, int)> 表示 "接受兩個(gè)int，返回int"的可調(diào)用對(duì)象
    function<int(int, int)> f1 = f;                           // 包裝普通函數(shù)
    function<int(int, int)> f2 = Functor();                   // 包裝仿函數(shù)
    function<int(int, int)> f3 = [](int a, int b) {           // 包裝lambda
        return a + b;
    };
    cout << f1(1, 1) << endl;  // 2
    cout << f2(2, 2) << endl;  // 4
    cout << f3(3, 3) << endl;  // 6
    return 0;
}

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() {
    // 靜態(tài)成員函數(shù) → 和普通函數(shù)一樣包裝，不需要額外對(duì)象參數(shù)
    function<int(int, int)> f4 = &Plus::plusi;
    cout << f4(1, 1) << endl;  // 2
    // 普通成員函數(shù) → 第一個(gè)參數(shù)是調(diào)用它的對(duì)象（用指針）
    function<double(Plus*, double, double)> f5 = &Plus::plusd;
    Plus pl;
    cout << f5(&pl, 1.1, 1.1) << endl;  // 通過(guò)指針調(diào)用
    // 也可以用對(duì)象值傳遞
    function<double(Plus, double, double)> f6 = &Plus::plusd;
    cout << f6(pl, 1.1, 1.1) << endl;     // pl以值方式傳入
    cout << f6(Plus(), 1.1, 1.1) << endl; // 臨時(shí)對(duì)象也可以
    // 甚至可以用右值引用
    function<double(Plus&&, double, double)> f7 = &Plus::plusd;
    cout << f7(move(pl), 1.1, 1.1) << endl;
    cout << f7(Plus(), 1.1, 1.1) << endl;
    return 0;
}

int main() {
    // 字符串 → 操作函數(shù)的映射表
    map<string, function<int(int, int)>> opFuncMap = {
        {"+", [](int x, int y) { return x + y; }},
        {"-", [](int x, int y) { return x - y; }},
        {"*", [](int x, int y) { return x * y; }},
        {"/", [](int x, int y) { return x / y; }},
        {"&", [](int x, int y) { return x & y; }},
        {"|", [](int x, int y) { return x | y; }},
        {"^", [](int x, int y) { return x ^ y; }}
    };
    // 使用起來(lái)極其方便
    cout << opFuncMap["+"](3, 5) << endl;  // 8
    cout << opFuncMap["*"](3, 5) << endl;  // 15
    cout << opFuncMap["^"](6, 3) << endl;  // 5
    return 0;
}

int Sub(int a, int b) {
    return (a - b) * 10;
}

// 老辦法：手動(dòng)包裝
auto sub100 = [](int b) {
    return Sub(100, b);
};
cout << sub100(5) << endl;  // (100 - 5) * 10 = 950

#include <functional>
using namespace std;
using placeholders::_1;
using placeholders::_2;
using placeholders::_3;
// 一行搞定：把 Sub 的第一個(gè)參數(shù)固定為 100
auto sub100 = bind(Sub, 100, _1);
cout << sub100(5) << endl;   // (100 - 5) * 10 = 950

using placeholders::_1;
using placeholders::_2;
using placeholders::_3;
// ... 需要幾個(gè)就 using 幾個(gè)

int Sub(int a, int b) { return (a - b) * 10; }
// 固定第一個(gè)參數(shù)為100
auto sub1 = bind(Sub, 100, _1);
cout << sub1(5) << endl;   // Sub(100, 5) = 950
// 固定第二個(gè)參數(shù)為100
auto sub2 = bind(Sub, _1, 100);
cout << sub2(5) << endl;   // Sub(5, 100) = -950

// 原本是 Sub(a, b)，現(xiàn)在讓調(diào)用者的第一個(gè)參數(shù)傳給b，第二個(gè)傳給a
auto sub3 = bind(Sub, _2, _1);
cout << sub3(10, 5) << endl;  // Sub(5, 10) = -50  (參數(shù)被交換了！)
cout << Sub(10, 5) << endl;   // Sub(10, 5) = 50  （原始順序）

int SubX(int a, int b, int c) {
    return (a - b - c) * 10;
}
// 分別固定第1、第2、第3個(gè)參數(shù)為100
auto sub5 = bind(SubX, 100, _1, _2);  // 固定a=100，b和c由調(diào)用者提供
auto sub6 = bind(SubX, _1, 100, _2);  // 固定b=100，a和c由調(diào)用者提供
auto sub7 = bind(SubX, _1, _2, 100);  // 固定c=100，a和b由調(diào)用者提供
cout << sub5(5, 1) << endl;  // SubX(100, 5, 1) = 940
cout << sub6(5, 1) << endl;  // SubX(5, 100, 1) = -960
cout << sub7(5, 1) << endl;  // SubX(5, 1, 100) = -960

class Plus {
public:
    Plus(int n = 10) : _n(n) {}
    double plusd(double a, double b) {
        return (a + b) * _n;
    }
private:
    int _n;
};
int main() {
    // function方式：對(duì)象需要每次傳入
    function<double(Plus, double, double)> f6 = &Plus::plusd;
    cout << f6(Plus(), 1.1, 1.1) << endl;
    // bind方式：對(duì)象一次性綁定，后續(xù)調(diào)用和普通函數(shù)完全一樣
    function<double(double, double)> f8 = bind(&Plus::plusd, Plus(), _1, _2);
    cout << f8(1.1, 1.1) << endl;  // 不需要再傳對(duì)象！
    return 0;
}

// 復(fù)利計(jì)算：返回利息金額
// rate: 年利率，money: 本金，year: 年數(shù)
auto calcInterest = [](double rate, double money, int year) -> double {
    double ret = money;
    for (int i = 0; i < year; i++) {
        ret += ret * rate;
    }
    return ret - money;
};
cout << calcInterest(0.05, 10000000, 30) << endl;  // 5%年利率，1000萬(wàn)，30年

// 1.5%年利率系列
function<double(double)> func3_1_5  = bind(calcInterest, 0.015, _1, 3);
function<double(double)> func5_1_5  = bind(calcInterest, 0.015, _1, 5);
function<double(double)> func10_1_5 = bind(calcInterest, 0.015, _1, 10);
// 2.5%年利率系列
function<double(double)> func3_2_5  = bind(calcInterest, 0.025, _1, 3);
function<double(double)> func5_2_5  = bind(calcInterest, 0.025, _1, 5);
function<double(double)> func10_2_5 = bind(calcInterest, 0.025, _1, 10);
// 使用時(shí)只需傳入本金
cout << "1.5% 存3年，100萬(wàn) → " << func3_1_5(1000000) << endl;
cout << "1.5% 存5年，100萬(wàn) → " << func5_1_5(1000000) << endl;
cout << "1.5% 存10年，100萬(wàn) → " << func10_1_5(1000000) << endl;
cout << "2.5% 存3年，100萬(wàn) → " << func3_2_5(1000000) << endl;
cout << "2.5% 存5年，100萬(wàn) → " << func5_2_5(1000000) << endl;
cout << "2.5% 存10年，100萬(wàn) → " << func10_2_5(1000000) << endl;

lambda        →  快速定義一個(gè)"匿名函數(shù)"，就地使用
function      →  用一個(gè)"統(tǒng)一的類型"來(lái)保存和傳遞各種可調(diào)用對(duì)象
bind          →  把已有的可調(diào)用對(duì)象的某些參數(shù)"固定"住，生成簽名單一的新對(duì)象

// 1. 用 lambda 定義核心邏輯
auto calc = [](double rate, double money, int year) -> double {
    double ret = money;
    for (int i = 0; i < year; i++) ret += ret * rate;
    return ret - money;
};
// 2. 用 bind 固定部分參數(shù)
auto fiveYearFund = bind(calc, 0.035, _1, 5);
// 3. 用 function 統(tǒng)一存儲(chǔ)
map<string, function<double(double)>> products;
products["穩(wěn)健型5年"] = fiveYearFund;
products["進(jìn)取型5年"] = bind(calc, 0.06, _1, 5);
// 4. 調(diào)用
cout << products["穩(wěn)健型5年"](100000) << endl;

可變參數(shù)模板 (Args...)
    ↓
參數(shù)包展開(kāi)的兩種方式（遞歸展開(kāi) / 逗號(hào)表達(dá)式展開(kāi)）
    ↓
可變參數(shù) + 完美轉(zhuǎn)發(fā) → emplace_back 原地構(gòu)造
    ↓
lambda 表達(dá)式 → 捕獲列表 / 值 vs 引用 / 隱式捕獲
    ↓
std::function → 統(tǒng)一各種可調(diào)用對(duì)象的類型
    ↓
std::bind → 固定參數(shù)、調(diào)整順序、簡(jiǎn)化調(diào)用