C++ 基础知识

// 整型
int, short, long, long long          // 有符号
unsigned int, uint32_t, size_t       // 无符号（推荐用 <cstdint> 固定宽度类型）

// 浮点
float, double, long double

// 字符与布尔
char, wchar_t, char8_t(C++20), char16_t, char32_t
bool                                 // true / false

// 空类型
void                                 // 无返回值/无类型
std::nullptr_t                       // nullptr 的类型（C++11）

int a = 42;              // 拷贝初始化
int b(42);               // 直接初始化
int c{42};               // 列表初始化（C++11，推荐，防止窄化转换）
auto d = 42;             // 类型推导（C++11）
const int e = 100;       // 常量
constexpr int f = 200;   // 编译期常量（C++11）
constinit int g = 300;   // 编译期初始化（C++20，解决静态初始化顺序问题）

struct Point {
    int x, y;
    auto operator<=>(const Point&) const = default; // 自动生成所有比较运算符
};

// if-else（C++17 支持初始化语句）
if (auto it = map.find(key); it != map.end()) {
    use(it->second);
}

// switch（C++17 同样支持初始化语句）
switch (auto val = get_value(); val) { ... }

// range-for（C++11，最常用遍历方式）
for (const auto& item : container) { ... }

// 传统 for / while / do-while
// break, continue, return

// 普通函数
int add(int a, int b) { return a + b; }

// 默认参数
void log(const std::string& msg, int level = 0);

// 重载
void print(int);
void print(const std::string&);

// 内联（建议由编译器决定，显式 inline 仅用于头文件定义）
inline int square(int x) { return x * x; }

// constexpr 函数（C++11/14/17/20 逐步放宽限制）
constexpr int factorial(int n) {
    if (n <= 1) return 1;
    return n * factorial(n - 1);
}

// Lambda 表达式（C++11，极其重要）
auto greet = [](const std::string& name) -> std::string {
    return "Hello, " + name;
};

// 捕获列表：[=] 值捕获, [&] 引用捕获, [x, &y] 混合, [*this] C++17
// C++20 模板 lambda
auto add = []<typename T>(T a, T b) { return a + b; };

// C++23 递归 lambda（deducing this）
auto fib = [](this auto self, int n) -> int {
    return n <= 1 ? n : self(n-1) + self(n-2);
};

class Widget {
public:
    Widget(int id);                    // 构造函数
    ~Widget();                         // 析构函数
    Widget(const Widget&);             // 拷贝构造
    Widget& operator=(const Widget&);  // 拷贝赋值
    Widget(Widget&&) noexcept;         // 移动构造（C++11）
    Widget& operator=(Widget&&) noexcept; // 移动赋值（C++11）

    void do_work() const;              // const 成员函数
    static Widget create();            // 静态工厂方法

private:
    int id_;
    std::string name_;
};

class Shape {
public:
    virtual ~Shape() = default;           // 虚析构（多态基类必须有）
    virtual double area() const = 0;      // 纯虚函数 → 抽象类
    virtual std::string name() const;     // 虚函数
};

class Circle : public Shape {
public:
    double area() const override;         // override 关键字（C++11，必加）
    std::string name() const final;       // final 禁止进一步重写
};

// 函数模板
template<typename T>
T max(T a, T b) { return (a > b) ? a : b; }

// 类模板
template<typename T, size_t N>
class Array {
    T data_[N];
public:
    constexpr size_t size() const { return N; }
};

// C++20 Concepts（约束模板参数）
template<std::integral T>        // 仅接受整数类型
T gcd(T a, T b);

template<typename T>
concept Printable = requires(T t) {
    { std::cout << t } -> std::same_as<std::ostream&>;
};

#include <memory>

// ✅ 独占所有权
auto ptr = std::make_unique<Widget>(42);

// ✅ 共享所有权
auto shared = std::make_shared<Widget>(42);
std::weak_ptr<Widget> weak = shared;  // 观察，不增加引用计数

// ❌ 永远不要这样
Widget* raw = new Widget(42);
delete raw;  // 容易泄漏、异常不安全

try {
    throw std::runtime_error("something went wrong");
} catch (const std::exception& e) {   // 始终按 const 引用捕获
    std::cerr << e.what() << '\n';
}

// noexcept 标记不抛异常的函数（启用移动语义优化）
Widget(Widget&&) noexcept;