告别冗长代码！C++17 模板推导神器 CTAD，写出令人惊艳的代码

// 看这个常见场景
auto names = std::vector{"张三", "李四", "王五"}; // C++17 CTAD自动推导
auto scores = std::map{
    {"张三", 95},
    {"李四", 87},
    {"王五", 92}
}; // 自动推导为 map<const char*, int>

// 传统写法：又臭又长 😅
std::pair<int, double> p(2, 4.5);
std::tuple<int, int, double> t(4, 3, 2.5);

// CTAD写法：简洁优雅 ✨
std::pair p(2, 4.5);     
std::tuple t(4, 3, 2.5); 

// 🏗️ 首先定义一个简单的模板类
template<class T>
class MyBox {
    T data;
public:
    // 🔑 构造函数是CTAD工作的关键
    MyBox(T value) : data(value) {}
    
    // 📖 提供一个getter方法来访问数据
    T get() const { return data; }
};

// 使用示例
MyBox box1(42);        // MyBox<int> 自动推导 ✨
MyBox box2("C++17");   // MyBox<const char*> 自动推导 ✨

template<typename T, typename U>
struct Wrapper {
    T first;
    U second;
    Wrapper(T f, U s) : first(f), second(s) {}
};

// 这样可以 ✅
Wrapper w1(1, "hello");  // 自动推导为 Wrapper<int, const char*>

// 这样不行 ❌
Wrapper w2{1, "hello"};  // 编译错误！

template<typename T>
struct Value {
    T data;
    Value(T d) : data(d) {}
};

// 圆括号初始化：允许窄化转换
Value v1(3.14);    // OK：double -> int，虽然小数部分丢失
Value v2(1000);    // OK：即使T是int8_t，也能编译（可能溢出）

// 花括号初始化：禁止窄化转换
Value v3{3.14};    // 错误：double不能窄化为int
Value v4{1000};    // 如果T是int8_t，编译错误（超出范围）

// 实际应用场景
std::vector<int> vec1(3.14);    // OK：创建3个元素
std::vector<int> vec2{3.14};    // 错误：3.14不能窄化为int

// std::initializer_list 的基本用法
std::vector<int> numbers{1, 2, 3, 4, 5};  // 使用初始化列表构造

class MyContainer {
public:
    // 使用初始化列表构造函数
    MyContainer(std::initializer_list<int> list) {
        for(int value : list) {
            // 处理每个元素
        }
    }
};

// 使用示例
MyContainer c{1, 2, 3, 4, 5};  // 使用花括号初始化

std::vector<int> v1(3, 5);    // 创建3个元素，每个值为5
std::vector<int> v2{3, 5};    // 创建2个元素：3和5

class Widget {
public:
    Widget(int i, int j) {}                           // #1
    Widget(std::initializer_list<int> il) {}          // #2
};

Widget w1(10, 20);    // 调用 #1
Widget w2{10, 20};    // 调用 #2，因为优先选择初始化列表构造函数

// 1. 别名模板的推导 
template<class T>
using MyVector = std::vector<T>;  // 定义一个vector的别名 📦

MyVector v{1, 2, 3}; // 神奇吧! 自动推导为 MyVector<int> ✨

// 2. 非类型模板参数的推导 
template<class T>
struct Array {
    constexpr Array(T) {}  // 注意这个构造函数是constexpr的 🔑
};

template<Array x>  // 这里Array x是一个非类型模板参数 🎯
struct Container {}; 

Container<42> c;   // 编译器会自动推导为 Container<Array<int>(42)> 🚀

// 3. 聚合类的推导 (C++20新特性)
template<class T, class U>
struct Point {
    T x;  // 第一个成员 📍
    U y;  // 第二个成员 📍
};

Point p{1, 2.0};  // 看这里! 自动推导为 Point<int, double> ✨
                  // x被推导为int, y被推导为double

template<class T>
struct Container {
    T value;
    Container(T v) : value(v) {} // 👈 从构造函数推导
};

Container c1(42);     // ✨ 自动推导为 Container<int>
Container c2(c1);     // 🔄 从复制构造函数推导
Container c3(std::move(c1)); // 🚀 从移动构造函数推导

template<class T>
struct SmartPtr {
    T* ptr;
    SmartPtr(T* p) : ptr(p) {} // 🔑 基础构造函数
};

// 🎯 自定义推导规则
SmartPtr(char const*) -> SmartPtr<std::string>;  

// 📝 这个推导指引的含义是：
// - 当看到 const char* 类型的参数时
// - 不要使用默认的 SmartPtr<const char> 推导
// - 而是使用 SmartPtr<string> 作为目标类型

SmartPtr ptr{"hello"};  // ✨ 推导为 SmartPtr<std::string>
                        // 🎯 而不是 SmartPtr<const char>

// 📦 基础容器模板
template<typename T>
struct Container {
    T value;
};

// 🔄 数组类型的特殊推导指引
template<typename T, std::size_t N>
Container(T (&)[N]) -> Container<std::array<T, N>>;

// 💡 这个推导指引会：
// - 捕获原始数组的元素类型(T)和长度(N)
// - 将其转换为等价的 std::array 类型

int arr[] = {1, 2, 3};
Container c(arr);  // 🎯 自动推导为 Container<std::array<int, 3>>
                   // ✨ 而不是 Container<int[3]>

// 传统写法：类型声明太冗长了 😫
std::pair<int, double> p1(1, 2.5);
std::tuple<std::string, int, double> t1("hello", 1, 3.14);

// CTAD写法：简洁优雅 ✨
std::pair p2(1, 2.5);                    // 自动推导类型
std::tuple t2("hello", 1, 3.14);         // 让编译器来做这件事

// 圆括号初始化 - CTAD的最佳搭档 ✅
std::vector v1(3, 42);        // 创建包含3个42的vector
std::pair p1(1, "hello");     // 完美推导类型

// 花括号初始化 - 需要小心使用 ⚠️
std::vector v2{3, 42};        // 创建包含3和42两个元素的vector
std::pair p2{1, "hello"};     // 某些情况可能推导失败

// 首先定义一个模板类 📦
template<class T>
struct MyContainer {
    MyContainer(std::initializer_list<T> list) {}
};

// 添加推导指引 - 告诉编译器如何推导 🎯
template<class T>
MyContainer(std::initializer_list<T>) -> MyContainer<T>;

// 现在可以愉快地使用了 ✨
MyContainer c{1, 2, 3};  // 自动推导为 MyContainer<int>