#include <iostream>
#include <string>
#include <vector>
using namespace std;

int main() {
    // 1. 基本類型推導(dǎo)
    auto a = 10;          // 推導(dǎo)為 int
    auto b = 3.14;        // 推導(dǎo)為 double
    auto c = 'A';         // 推導(dǎo)為 char
    auto d = true;        // 推導(dǎo)為 bool
    auto e = "hello";     // 推導(dǎo)為 const char*（字符串字面量是const char[]）
    auto f = string("hi");// 推導(dǎo)為 std::string

    // 驗(yàn)證推導(dǎo)結(jié)果（通過(guò)typeid查看類型）
    cout << typeid(a).name() << endl; // 輸出：int（不同編譯器輸出可能略有差異，比如MSVC輸出int，GCC輸出i）
    cout << typeid(e).name() << endl; // 輸出：const char*

    // 2. 復(fù)雜類型推導(dǎo)（解決冗長(zhǎng)類型名問題）
    vector<vector<int>> matrix = {{1,2}, {3,4}};
    // 傳統(tǒng)寫法：vector<vector<int>>::iterator it = matrix.begin();
    auto it = matrix.begin(); // 推導(dǎo)為 vector<vector<int>>::iterator
    cout << (*it)[0] << endl; // 輸出：1

    return 0;
}

#include <iostream>
using namespace std;

int main() {
    const int x = 10;
    auto y = x;         // y的類型是int（頂層const被忽略）
    y = 20;             // 可以修改，證明y不是const
    
    const auto z = x;   // z的類型是const int（手動(dòng)加const，保留常量屬性）
    // z = 30;          // 編譯錯(cuò)誤：z是const int，不能修改

    volatile int m = 20;
    auto n = m;         // n的類型是int（頂層volatile被忽略）

    return 0;
}

#include <iostream>
using namespace std;

int main() {
    int val = 100;
    int& ref_val = val;
    
    auto a = ref_val;   // a的類型是int（忽略引用）
    a = 200;
    cout << val << endl; // 輸出：100（a是拷貝，不影響val）

    auto& b = ref_val;  // b的類型是int&（手動(dòng)加&，保留引用）
    b = 200;
    cout << val << endl; // 輸出：200（b是引用，修改影響val）

    const int c = 50;
    const int& ref_c = c;
    auto d = ref_c;     // d的類型是int（忽略引用，頂層const也忽略）
    auto& e = ref_c;    // e的類型是const int&（保留底層const和引用）
    // e = 60;          // 編譯錯(cuò)誤：e指向const int

    int* p = &val;
    auto q = p;         // q的類型是int*（保留指針）
    const int* pc = &c;
    auto r = pc;        // r的類型是const int*（保留底層const的指針）

    return 0;
}

#include <iostream>
using namespace std;

void func() {
    cout << "func called" << endl;
}

int main() {
    int arr[5] = {1,2,3,4,5};
    auto a = arr;       // a的類型是int*（數(shù)組退化為指針）
    cout << *(a+1) << endl; // 輸出：2

    auto& b = arr;      // b的類型是int (&)[5]（數(shù)組的引用，保留數(shù)組類型）
    cout << b[2] << endl;   // 輸出：3
    cout << sizeof(b) << endl; // 輸出：20（5個(gè)int，每個(gè)4字節(jié)）

    auto f = func;      // f的類型是void (*)()（函數(shù)指針）
    f();                // 調(diào)用func，輸出：func called

    return 0;
}

#include <iostream>
#include <map>
#include <string>
using namespace std;

int main() {
    // 復(fù)雜容器的迭代器
    map<string, map<int, string>> complex_map;
    complex_map["user1"][1001] = "Tom";
    
    // 傳統(tǒng)寫法（冗長(zhǎng)且易出錯(cuò)）：
    // map<string, map<int, string>>::iterator it = complex_map.begin();
    auto it = complex_map.begin(); // 簡(jiǎn)潔明了
    cout << it->first << ": " << it->second[1001] << endl; // 輸出：user1: Tom

    return 0;
}

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<int> nums = {10,20,30,40};
    
    // 只讀遍歷（拷貝）
    for (auto val : nums) {
        cout << val << " ";
    }
    cout << endl;

    // 修改遍歷（引用）
    for (auto& val : nums) {
        val *= 2;
    }

    // 只讀遍歷（const引用，避免拷貝，效率更高）
    for (const auto& val : nums) {
        cout << val << " "; // 輸出：20 40 60 80
    }

    return 0;
}

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

int main() {
    vector<int> nums = {3,1,4,1,5,9};
    
    // Lambda表達(dá)式的變量必須用auto聲明
    auto compare = [](int a, int b) { return a > b; };
    sort(nums.begin(), nums.end(), compare);

    for (auto val : nums) {
        cout << val << " "; // 輸出：9 5 4 3 1 1
    }

    return 0;
}

#include <iostream>
using namespace std;

template <typename T1, typename T2>
auto add(T1 a, T2 b) -> decltype(a + b) { // C++11尾返回類型（配合auto）
    return a + b;
}

int main() {
    auto res1 = add(10, 20.5); // res1推導(dǎo)為double（10+20.5=30.5）
    auto res2 = add(5, 3);     // res2推導(dǎo)為int（5+3=8）
    cout << res1 << " " << res2 << endl; // 輸出：30.5 8

    return 0;
}

// 錯(cuò)誤示例
auto x; // 編譯錯(cuò)誤：auto變量必須初始化
x = 10;

// 錯(cuò)誤示例
void func(auto x) { // 編譯錯(cuò)誤：參數(shù)不能用auto
    cout << x << endl;
}

// 正確替代方案：用模板
template <typename T>
void func(T x) {

// 錯(cuò)誤示例
auto arr[5] = {1,2,3,4,5}; // 編譯錯(cuò)誤：auto不能聲明數(shù)組

// 正確寫法
int raw_arr[5] = {1,2,3,4,5};
auto* arr_ptr = raw_arr;    // 推導(dǎo)為int*
auto& arr_ref = raw_arr;    // 推導(dǎo)為int (&)[5]

int val = 10;
const int& ref = val;

auto a = ref;       // a是int，丟失const和引用
const auto& b = ref;// b是const int&，保留屬性

// 不推薦（可讀性差）
auto x = 10; // 直接寫int x = 10更清晰

// 推薦（類型冗長(zhǎng)）
vector<map<int, string>> vec;
auto it = vec.begin(); // 比寫完整迭代器類型更清晰