后置返回类型与 noexcept

auto add(int a, int b) -> int;  // 等价于 int add(int a, int b);

#include <iostream>
#include <type_traits>
#include <typeinfo>
#include <string>
#include <vector>

// 不使用后置返回类型：需要冗长的 decltype 前置
// 这无法编译！因为 a 和 b 在返回类型处还不可见
// template<typename T, typename U>
// decltype(T{} + U{}) broken_add(T a, U b) { return a + b; }

// C++11 后置返回类型：简洁且正确
template <typename T, typename U>
auto add(T a, U b) -> decltype(a + b) {
    return a + b;
}

// C++14：auto 自动推导返回类型（不需要后置了）
template <typename T, typename U>
auto add14(T a, U b) {
    return a + b;
}

// 但复杂场景后置返回类型仍然有用
template <typename Container>
auto get_element(Container& c, size_t index) -> decltype(c[index]) {
    return c[index];
}

int main() {
    std::cout << "===== 后置返回类型 =====" << std::endl;

    // 混合类型运算，返回类型由 decltype(a+b) 确定
    auto r1 = add(3, 4.5);         // decltype(3 + 4.5) = double
    auto r2 = add(std::string("C++"), "11");  // decltype = std::string

    std::cout << "int + double = " << r1
              << " (类型: " << typeid(r1).name() << ")" << std::endl;
    std::cout << "string + const char* = " << r2
              << " (类型: " << typeid(r2).name() << ")" << std::endl;

    // get_element：返回类型取决于容器的 operator[]
    std::vector<int> vec = {10, 20, 30};
    auto elem = get_element(vec, 1);
    std::cout << "\nvec[1] = " << elem << " → 返回 int&" << std::endl;
    // 注意：get_element 返回容器的元素引用，可修改原数据

    // Lambda 中的后置返回类型（C++11 必需，C++14 可省略）
    auto lambda = [](int a, double b) -> double {
        return a * b;
    };
    std::cout << "Lambda: 3 * 4.5 = " << lambda(3, 4.5) << std::endl;

    return 0;
}

#include <iostream>
#include <vector>
#include <string>
#include <chrono>

// 没有 noexcept 的类：vector 扩容时不会使用移动
class NoNoexcept {
public:
    std::string data;

    explicit NoNoexcept(std::string d) : data(std::move(d)) {
        std::cout << "  构造: " << data << std::endl;
    }

    NoNoexcept(const NoNoexcept& other) : data(other.data) {
        std::cout << "  拷贝: " << data << std::endl;
    }

    // 移动构造没有 noexcept！
    NoNoexcept(NoNoexcept&& other) : data(std::move(other.data)) {
        std::cout << "  移动: " << data << std::endl;
    }
};

// 有 noexcept 的类：vector 扩容时会使用移动
class YesNoexcept {
public:
    std::string data;

    explicit YesNoexcept(std::string d) : data(std::move(d)) {
        std::cout << "  构造: " << data << std::endl;
    }

    YesNoexcept(const YesNoexcept& other) : data(other.data) {
        std::cout << "  拷贝: " << data << std::endl;
    }

    YesNoexcept(YesNoexcept&& other) noexcept
        : data(std::move(other.data)) {
        std::cout << "  移动: " << data << std::endl;
    }
};

int main() {
    std::cout << "===== 无 noexcept 移动: vector 扩容 =====" << std::endl;
    {
        std::vector<NoNoexcept> v;
        v.reserve(1);
        std::cout << "push_back 第 1 个:" << std::endl;
        v.emplace_back("first");

        std::cout << "push_back 第 2 个（触发扩容）:" << std::endl;
        v.emplace_back("second");  // 扩容：但会用拷贝而非移动！
    }

    std::cout << "\n===== 有 noexcept 移动: vector 扩容 =====" << std::endl;
    {
        std::vector<YesNoexcept> v;
        v.reserve(1);
        std::cout << "push_back 第 1 个:" << std::endl;
        v.emplace_back("first");

        std::cout << "push_back 第 2 个（触发扩容）:" << std::endl;
        v.emplace_back("second");  // 扩容：使用移动（高效）
    }

    // noexcept 运算符
    std::cout << "\n===== noexcept 运算符 =====" << std::endl;
    std::cout << "int + int 可能抛异常? "
              << std::boolalpha
              << !noexcept(1 + 1) << std::endl;

    std::cout << "YesNoexcept 移动构造 noexcept? "
              << noexcept(YesNoexcept(std::move(*std::declval<YesNoexcept*>())))
              << std::endl;

    std::cout << "NoNoexcept 移动构造 noexcept? "
              << noexcept(NoNoexcept(std::move(*std::declval<NoNoexcept*>())))
              << std::endl;

    return 0;
}

#include <iostream>
#include <vector>
#include <type_traits>

// 条件 noexcept：仅当 T 的 swap 不抛异常时，才承诺不抛异常
template <typename T>
void safe_swap(T& a, T& b) noexcept(noexcept(std::swap(a, b))) {
    std::swap(a, b);
}

// noexcept 对析构函数的影响
class Resource {
public:
    Resource() { std::cout << "获取资源" << std::endl; }
    ~Resource() noexcept {  // 析构函数默认 noexcept
        std::cout << "释放资源" << std::endl;
    }
};

int main() {
    int x = 1, y = 2;
    std::cout << "safe_swap<int> 是 noexcept? "
              << noexcept(safe_swap(x, y)) << std::endl;

    {
        Resource r;  // 析构时自动释放
    }

    return 0;
}