C++ 基础知识点详解（中级）

int a = 10;

// 左值：有名字，可取地址
int& ref = a;        // ✅ a 是左值
int* ptr = &a;       // ✅ 可以取地址
a = 20;              // ✅ 可以放在等号左边

// 右值：没有名字，不可取地址
int& ref2 = 10;      // ❌ 10 是右值，不能用普通引用绑定
int* ptr2 = &10;     // ❌ 右值不能取地址
10 = a;              // ❌ 右值不能放在等号左边

int x = 42;

// 左值引用：只能绑定左值
int& lref = x;       // ✅ x 是左值
int& lref2 = 42;     // ❌ 42 是右值

// 右值引用：只能绑定右值
int&& rref = 42;     // ✅ 42 是右值
int&& rref2 = x;     // ❌ x 是左值

// const 左值引用：特例，可以绑定右值（延长临时对象生命周期）
const int& cref = 42; // ✅ const 引用可以绑定右值

std::string a = std::string("hello") + std::string(" world");
// 右侧的拼接结果是右值（临时对象），即将销毁
// 用移动语义直接把它的内部缓冲区"偷过来"，而不是拷贝一份
// std::string 的 move 构造函数自动处理这个过程

class MyString {
    char* data;
    size_t len;

public:
    // 移动构造函数
    MyString(MyString&& other) noexcept
        : data(other.data), len(other.len) {
        other.data = nullptr;  // 原对象释放所有权
        other.len = 0;
    }

    // 移动赋值运算符
    MyString& operator=(MyString&& other) noexcept {
        if (this != &other) {
            delete[] data;             // 释放自己原有资源
            data = other.data;          // 窃取对方资源
            len = other.len;
            other.data = nullptr;
            other.len = 0;
        }
        return *this;
    }
};

std::string a = "hello";
std::string b = a;              // 拷贝 a 的内容（a 是左值 → 调用拷贝构造函数）
std::string c = std::move(a);   // 移动 a 的内容到 c（a 被转为右值引用 → 调用移动构造函数）

std::vector<std::string> vec;
vec.push_back("hello");         // ✅ "hello" 是右值 → 移动构造
vec.push_back(std::move(a));    // ✅ 显式 std::move → 移动构造
vec.push_back(a);               // ❌ a 是左值 → 拷贝构造

template<typename T>
void wrapper(T&& arg) {
    // 问题：arg 在函数内部是左值（它有名字！）
    // 如果原调用传入的是右值，这里转发过去变成了左值
    // 被调函数就会调用拷贝构造而不是移动构造
    func(arg);  // ❌ 丢失了右值属性
}

template<typename T>
void wrapper(T&& arg) {
    func(std::forward<T>(arg));  // ✅ 完美转发，保持原始值类别
}

// 普通右值引用：只能绑定右值
void f(int&& x);

// 模板中的 T&&：是转发引用，左值右值都能绑定
template<typename T>
void f(T&& x);

// 对比
f(42);        // 普通右值引用 ✅ / 转发引用 ✅
int a = 42;
f(a);         // 普通右值引用 ❌ / 转发引用 ✅

class Buffer {
    char* data;
    size_t size;
public:
    // 拷贝构造：深拷贝（开销大）
    Buffer(const Buffer& other) : size(other.size) {
        data = new char[size];                 // 重新分配
        memcpy(data, other.data, size);        // 逐字节拷贝
    }

    // 移动构造：转移指针（开销几乎为零）
    Buffer(Buffer&& other) noexcept
        : data(other.data), size(other.size) {
        other.data = nullptr;   // 原对象置空，防止 double free
        other.size = 0;
    }
};

std::vector<Buffer> v;
Buffer b(1024);
v.push_back(std::move(b));   // 显式移动，转移而非拷贝 1024 字节

Buffer makeBuffer() {
    Buffer temp(2048);
    return temp;             // 返回局部对象，触发移动（或 RVO）
}

// Rule of Zero 示例：不写任何拷贝/移动，交给编译器
class Modern {
    std::vector<int> data;   // vector 自己管理资源
    std::unique_ptr<int> p;  // unique_ptr 自己管理资源
    // 默认拷贝/移动都正确（或不可拷贝，语义正确）
};

// 内置类型
int a{10};
double b{3.14};
int arr[]{1, 2, 3, 4, 5};

// 容器
std::vector<int> vec{1, 2, 3};
std::map<int, std::string> m{{1, "one"}, {2, "two"}};

// 自定义类型
struct Point { double x, y, z; };
Point p{1.0, 2.0, 3.0};

// new 表达式
int* arr2 = new int[3]{1, 2, 3};

int a = 10;       // 拷贝初始化
int b(10);        // 直接初始化（括号）
int c{10};        // 列表初始化（花括号）C++11
int d = {10};     // 等号 + 列表初始化

double pi = 3.14159;

int a(pi);        // ✅ 编译通过，但精度丢失（3.14159 → 3）
int b(pi);        // ✅ 同上

int c{pi};        // ❌ 编译错误！类型窄化（narrowing conversion）
int d{3.14};      // ❌ 同上，double 转 int 会丢失精度

class MyVector {
    std::vector<int> data;
public:
    // 用 initializer_list 构造函数
    MyVector(std::initializer_list<int> init) : data(init) {}
};

// 可以传入任意数量的元素
MyVector v{1, 2, 3, 4, 5, 6, 7};

std::vector<int> a(5);        // 构造一个大小为 5 的 vector，元素全为 0
std::vector<int> b{5};        // 构造一个包含单个元素 {5} 的 vector
std::vector<int> c = {1,2,3}; // 列表初始化，包含三个元素

// 空花括号表示值初始化（零初始化）
int x{};                      // x = 0
double y{};                   // y = 0.0

auto i = 42;                // int
auto d = 3.14;              // double
auto str = std::string{"hello"}; // std::string

// 典型场景：容器迭代
std::map<std::string, int> m;
for (auto it = m.begin(); it != m.end(); ++it) {
    std::cout << it->first << ": " << it->second << std::endl;
}

// 互斥锁的 RAII 用法
std::mutex mtx;
void thread_func() {
    std::lock_guard<std::mutex> lock(mtx);
    // 临界区代码
    // 函数退出（包括异常）时 lock 自动释放锁
}

#include <thread>
#include <iostream>

void task(int id) {
    std::cout << "Thread " << id << " running" << std::endl;
}

int main() {
    std::thread t1(task, 1);
    std::thread t2(task, 2);
    t1.join();
    t2.join();
}

// 基本语法：[捕获列表](参数) -> 返回值类型 { 函数体 }
auto add = [](int a, int b) { return a + b; };
std::cout << add(1, 2) << std::endl;  // 3

// 捕获列表
int x = 10;
auto byValue = [x]() { std::cout << x; };          // 值捕获
auto byRef = [&x]() { std::cout << x; };           // 引用捕获
auto allValue = [=]() { std::cout << x; };         // 捕获所有局部变量（值）
auto allRef = [&]() { std::cout << x; };           // 捕获所有局部变量（引用）
auto mixed = [x, &y]() {};                         // 混合捕获
auto init = [x = 10]() { return x; };              // C++14 初始化捕获

// 配合算法使用
std::vector<int> vec = {3, 1, 4, 1, 5, 9};
std::sort(vec.begin(), vec.end(),
    [](int a, int b) { return a > b; });  // 降序排列

#include <functional>

// std::function 可以包装任何可调用对象：函数指针、lambda、函数对象
std::function<int(int, int)> operation;

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

// 包装 lambda
operation = [](int a, int b) { return a * b; };

// 包装函数对象
struct Multiplier {
    int operator()(int a, int b) { return a * b * 2; }
};
operation = Multiplier{};

void process_data(std::vector<int>& data, std::function<bool(int)> predicate) {
    for (int& v : data) {
        if (predicate(v)) {
            // 处理满足条件的数据
        }
    }
}

// 调用时传入 lambda
process_data(data, [](int x) { return x > 0; });

void counter() {
    static int count = 0;  // 只在第一次调用时初始化为 0
    count++;
    std::cout << count << std::endl;
}

int main() {
    counter();  // 输出 1
    counter();  // 输出 2
    counter();  // 输出 3  （状态在调用之间保留）
}

void process() {
    // 每次调用都构造/析构，开销大
    // HeavyObject obj{...};

    // 只构造一次，之后复用
    static HeavyObject obj{...};
}

// file1.cpp
static int globalVar = 100;     // 只在 file1.cpp 内可见
static void helper() {}          // 只在 file1.cpp 内可见

// file2.cpp
// extern int globalVar;         // ❌ 编译错误，file1 的 globalVar 是 static
// helper();                     // ❌ 编译错误，找不到符号

class MyClass {
public:
    static int count;  // 声明
    MyClass() { count++; }
    ~MyClass() { count--; }
};

// static 成员变量必须在类外定义（C++11 之前）
int MyClass::count = 0;

int main() {
    MyClass a, b;
    std::cout << MyClass::count;  // 输出 2，所有实例共享
}

class MathUtils {
public:
    static int add(int a, int b) { return a + b; }
    static int subtract(int a, int b) { return a - b; }
};

// 调用方式（不需要创建对象）
int result = MathUtils::add(1, 2);

class Singleton {
public:
    // C++11 线程安全的局部 static 实现（推荐）
    static Singleton& instance() {
        static Singleton inst;  // C++11 保证线程安全初始化
        return inst;
    }

    void doSomething() { std::cout << "Doing something..." << std::endl; }

private:
    Singleton() = default;        // 私有构造函数
    ~Singleton() = default;
    Singleton(const Singleton&) = delete;       // 禁止拷贝
    Singleton& operator=(const Singleton&) = delete;
};

// 使用
Singleton::instance().doSomething();

const int MAX_SIZE = 100;
MAX_SIZE = 200;  // ❌ 编译错误：无法修改 const 变量

const double PI = 3.14159;

int a = 10, b = 20;

// 形态一：指向常量的指针（最常见）
const int* ptr1 = &a;
// *ptr1 = 20;     ❌ 不能通过此指针修改内容
ptr1 = &b;          ✅ 可以改变指向

// 形态二：常量指针（指针本身不能改）
int* const ptr2 = &a;
*ptr2 = 20;         ✅ 可以修改内容
// ptr2 = &b;       ❌ 不能改变指向

// 形态三：常量指针指向常量（都不能改）
const int* const ptr3 = &a;
// *ptr3 = 20;      ❌ 不能修改内容
// ptr3 = &b;       ❌ 不能改变指向

// 形态四：非常量指针指向非常量（普通指针）
int* ptr4 = &a;
*ptr4 = 20;         ✅ 可以修改内容
ptr4 = &b;          ✅ 可以改变指向

void printString(const std::string& str) {
    // str = "new value";  ❌ 不能修改
    std::cout << str << std::endl;
}

const int& ref = 42;        // ✅ 合法，临时对象生命周期延长到 ref 的作用域结束
int& ref2 = 42;             // ❌ 非法，非常量引用不能绑定右值

class Circle {
    double radius;
public:
    Circle(double r) : radius(r) {}

    // const 成员函数：只读操作
    double area() const {
        return 3.14159 * radius * radius;
        // radius = 5;      ❌ 编译错误：const 函数不能修改成员变量
    }

    // 非 const 成员函数：可以修改
    void setRadius(double r) {
        radius = r;          // ✅ 合法
    }
};

int main() {
    Circle c(5.0);
    std::cout << c.area();   // ✅ 可以调用

    const Circle c2(3.0);
    std::cout << c2.area();  // ✅ 可以调用 const 成员函数
    // c2.setRadius(4.0);    ❌ 编译错误：const 对象不能调用非 const 成员函数
}

class Cache {
    int data;
    mutable int accessCount;        // 可以随访问变化
    mutable bool isCached;          // 缓存状态标记
public:
    Cache(int d) : data(d), accessCount(0), isCached(false) {}

    int get() const {
        accessCount++;              // ✅ mutable 变量可以在 const 函数中修改
        return data;
    }
};

// 只读大对象：const 引用是标准写法
void process(const std::vector<int>& data) {
    // data.push_back(1);  ❌ 不能修改
}

// 小型类型：值传递即可
void setX(int x) { /* ... */ }

class Array {
    int data[100];
public:
    // 返回 const 引用，防止调用者修改内部数据
    const int& operator[](int index) const {
        return data[index];
    }
    // 非 const 版本，允许修改
    int& operator[](int index) {
        return data[index];
    }
};

const int x = 42;         // 常量，初始化时刻确定
constexpr int y = 42;     // 编译期常量，可用于数组大小等编译期场景

const int size = get_size();    // ✅ 合法，但只在运行时确定
constexpr int csize = get_size(); // ❌ 非法，get_size() 不是编译期函数

constexpr int get_size() { return 100; }  // 编译期函数
constexpr int csize2 = get_size();         // ✅ 合法，调用编译期函数

const int x = 10;
int* ptr = const_cast<int*>(&x);  // 去掉 const 属性
*ptr = 20;                        // 编译通过，但行为是**未定义的**（UB）！

#define PI 3.14159
#define MAX(a, b) ((a) > (b) ? (a) : (b))

// 预处理后，编译器看到的是：
// double area = 3.14159 * r * r;
// double m = ((3) > (5) ? (3) : (5));
// 宏名 PI 和 MAX 对编译器来说不存在

const double PI = 3.14159;
// 编译器知道 PI 是 double 类型，值为 3.14159
// 可以进行类型检查，符号表中可查

#define SQUARE(x) x * x

int result = SQUARE(3 + 2);
// 预处理后变成: 3 + 2 * 3 + 2 = 11（预期是 25！）
// 正确的写法需要加括号: #define SQUARE(x) ((x) * (x))

#define MAX(a, b) ((a) > (b) ? (a) : (b))

int i = 0;
MAX(i++, 5);
// i 可能被递增两次！因为 i++ 在宏中被展开了两次
// 而函数调用只会求值一次

#define DEBUG 1   // 全局可见，可能被其他文件同名宏冲突
// 调试时看不到 DEBUG，看到的是替换后的字面值 1

// 类型安全
const int MAX_SIZE = 100;
double d = MAX_SIZE;  // ✅ 隐式转换，编译器检查

// 作用域控制
class Config {
    static const int VERSION = 1;  // 只在类作用域内可见
};

// 可被调试器查看
const char* name = "test";  // 调试器可以看到 name 的值和类型

// 条件编译 —— const 无法替代
#ifndef DEBUG_MODE
#define DEBUG_MODE
#endif

#ifdef DEBUG_MODE
    // 调试代码
#endif

// 文件头部保护
#ifndef MY_HEADER_H
#define MY_HEADER_H
// header content
#endif

// 替代函数式宏 → 用 inline / constexpr 函数
// 旧写法: #define MAX(a, b) ((a) > (b) ? (a) : (b))
// 新写法:
template<typename T>
constexpr T max(T a, T b) { return a > b ? a : b; }
// 类型安全、只求值一次、编译器可优化

// 替代数值宏 → 用 enum class
// 旧写法: #define STATUS_OK 0
// 新写法:
enum class Status { OK, ERROR, PENDING };

// 替代魔法数字 → 用 inline constexpr
// 旧写法: #define MAX_RETRY 3
// 新写法:
inline constexpr int MAX_RETRY = 3;

// 非 inline 函数 —— 每次调用都有函数调用开销
int add(int a, int b) { return a + b; }

// inline 函数 —— 编译器将函数体直接替换到调用位置
inline int add(int a, int b) { return a + b; }

int main() {
    int x = add(1, 2);
    // 编译器可能将其优化为: int x = 1 + 2;
    // 省去了参数压栈、跳转、返回等指令
}

// 对比 inline 函数和宏：效果类似，但 inline 更安全
inline int square(int x) { return x * x; }     // ✅ 类型安全，只求值一次
#define SQUARE(x) ((x) * (x))                   // ❌ 无类型检查，可能多次求值

inline bool isValid(int x) { return x >= 0 && x < 100; }

for (int i = 0; i < 1000000; i++) {
    if (isValid(data[i])) {  // 100 万次调用，内联后几乎零开销
        process(data[i]);
    }
}

inline void complexFunction() {
    // 假设这里有 50 行代码...
    // 如果被调用了 1000 次，就多复制了 5000 行代码
}

// 递归函数 —— 编译器几乎不会内联
inline int factorial(int n) {
    return n <= 1 ? 1 : n * factorial(n - 1);  // 递归调用，无法内联展开
}

// utils.h
// C++98 时代，头文件中定义函数会导致多个 cpp 包含时产生重复定义
// 加了 inline 后，编译器知道这些定义在不同翻译单元是同一个函数
inline int helper(int x) { return x * 2; }

// config.h —— C++17 inline 变量
inline constexpr int MAX_RETRIES = 3;
inline std::string app_name = "MyApp";

# GCC 开启 LTO
g++ -flto -O2 main.cpp utils.cpp

# Clang 开启 LTO
clang++ -flto -O2 main.cpp utils.cpp

int* p;         // ❌ 未初始化，p 的值是随机的
*p = 5;         // ❌ 向随机地址写数据 → 未定义行为，可能崩溃

// ✅ 正确做法：声明即初始化
int* p = nullptr;  // 或 int* p = &some_valid_object;
if (p != nullptr) {
    *p = 5;
}

// 场景一：释放堆内存后继续使用
int* p = new int(10);
delete p;       // p 指向的内存已归还给操作系统
*p = 20;        // ❌ 悬挂指针！访问已释放内存 → 未定义行为

// ✅ 正确做法：释放后置空
delete p;
p = nullptr;    // 之后可以安全判断

// 场景二：指向已离开作用域的局部变量
int* getDangling() {
    int local = 100;
    return &local;   // ❌ 返回局部变量地址
}                    // local 的生命周期结束，返回的指针变为悬挂指针

// 场景三：容器元素失效
std::vector<int> v = {1, 2, 3};
int* p = &v[0];
v.push_back(4);   // vector 扩容，重新分配内存，p 可能失效（悬挂）

int flag = 0;

// 编译器可能优化：认为循环内 flag 不变，死循环 or 直接跳过
while (flag == 0) {
    // ...
}

volatile int flag = 0;

while (flag == 0) {
    // 每次都重新从内存读 flag
}

// 1. 硬件寄存器（内存映射 I/O）
volatile uint32_t* status_reg = (uint32_t*)0x40000000;
uint32_t status = *status_reg;   // 每次读取都真正访问硬件

// 2. 信号处理函数中共享的标志位
volatile sig_atomic_t interrupted = 0;
void handler(int) { interrupted = 1; }  // 主循环每次检查时都读内存

// 3. 中断服务程序（ISR）共享的变量
volatile int irq_counter = 0;

volatile int counter = 0;
counter++;   // ❌ 这其实是「读-改-写」三步，volatile 不保证原子性
             // 多线程下仍会丢更新 → 应该用 std::atomic<int>

class Complex {
public:
    double real, imag;
    Complex(double r, double i) : real(r), imag(i) {}

    // 重载 +：两个复数相加
    Complex operator+(const Complex& other) const {
        return Complex(real + other.real, imag + other.imag);
    }
};

Complex a(1, 2), b(3, 4);
Complex c = a + b;   // 调用 operator+，c = (4, 6)

// 常见重载
std::string s1 = "hello", s2 = "world";
std::string s3 = s1 + s2;              // operator+（std::string 已重载）

std::vector<int> v{1,2,3};
int x = v[0];                           // operator[]

// 流插入运算符 << 重载
std::ostream& operator<<(std::ostream& os, const Complex& c) {
    return os << c.real << " + " << c.imag << "i";
}
std::cout << a;   // 输出 "1 + 2i"

// typedef（C 时代）
typedef unsigned long uint_t;
typedef int (*FuncPtr)(double);              // 函数指针别名
typedef std::map<std::string, std::vector<int>> MyMap;  // 复杂类型

// using（C++11，赋值风格，可读性更好）
using uint_t = unsigned long;
using FuncPtr = int (*)(double);
using MyMap = std::map<std::string, std::vector<int>>;

// ✅ using 支持模板别名
template<typename T>
using Vec = std::vector<T>;
Vec<int> vi;        // 等价 std::vector<int>

// ❌ typedef 不能直接定义模板别名（编译错误）
// template<typename T>
// typedef std::vector<T> Vec;   // 非法！

// typedef 只能用 struct 包装来"模拟"
template<typename T>
struct VecWrapper {
    typedef std::vector<T> type;
};
VecWrapper<int>::type vi2;   // 冗长

// 传统 enum：作用域泄漏
enum Color { RED, GREEN, BLUE };
int c = RED;            // ✅ 隐式转 int（类型不安全）
// enum Traffic { RED, YELLOW, GREEN };  ❌ 编译错误：RED 已定义（命名冲突）

// enum class：作用域隔离
enum class Color2 { RED, GREEN, BLUE };
enum class Traffic { RED, YELLOW, GREEN };  // ✅ 不冲突，各自作用域

Color2 c2 = Color2::RED;          // ✅ 必须加作用域限定
// int i = Color2::RED;           ❌ 不隐式转 int
int i = static_cast<int>(Color2::RED);  // ✅ 显式转换

enum class Status : uint8_t { OK, ERROR, PENDING };  // 底层 8 位，节省内存
enum class Flags : uint32_t { A = 1, B = 2, C = 4 };  // 可用于位标志

class MyClass {
public:
    MyClass() = default;                     // 显式使用默认构造函数
    MyClass(const MyClass&) = default;       // 默认拷贝构造
    MyClass& operator=(const MyClass&) = default;  // 默认拷贝赋值
    ~MyClass() = default;                    // 默认析构
};

class MyClass {
public:
    MyClass(int x) {}        // 自定义了构造函数
    MyClass() = default;     // 默认构造函数本来不会生成了，这里显式要求
};

class NonCopyable {
public:
    NonCopyable(const NonCopyable&) = delete;            // 禁止拷贝构造
    NonCopyable& operator=(const NonCopyable&) = delete; // 禁止拷贝赋值
};

class Mutex {
public:
    Mutex(const Mutex&) = delete;   // 互斥锁不能拷贝
};

class OnlyInt {
public:
    OnlyInt(int x) {}
    OnlyInt(double) = delete;   // 禁止 double 隐式转 int 再构造
};

OnlyInt a(10);     // ✅
// OnlyInt b(3.14);  ❌ 编译错误：double 版本被 delete

template<typename T>
void process(T t) { /* ... */ }

template<>
void process<void*>(void*) = delete;   // 禁止 void* 版本

class FileGuard {
    FILE* fp;
public:
    FileGuard(const char* path) : fp(fopen(path, "r")) {}  // 构造：获取资源
    ~FileGuard() { if (fp) fclose(fp); }                   // 析构：释放资源
};

void func() {
    FileGuard f("data.txt");  // 获取资源
    // ... 中间可能 return 或抛异常 ...
    // 无论如何，f 析构时都会自动 fclose
}  // ✅ 自动释放

// 智能指针：自动释放内存
{
    auto p = std::make_unique<int>(42);
}  // p 析构，内存自动释放，无需 delete

// 锁：自动解锁
std::mutex mtx;
void f() {
    std::lock_guard<std::mutex> lock(mtx);
    // 临界区
    // 离开作用域（包括异常）自动解锁
}

// 算法回调：给 sort 传比较器
std::vector<int> v = {3, 1, 4, 1, 5};
std::sort(v.begin(), v.end(), [](int a, int b) { return a > b; });

// 捕获外部变量
int threshold = 10;
auto it = std::find_if(v.begin(), v.end(),
    [threshold](int x) { return x > threshold; });

#include <functional>

// 回调接口：接受任何 int(int) 的可调用对象
void register_callback(std::function<int(int)> cb) {
    int result = cb(42);
}

register_callback([](int x) { return x * 2; });          // lambda
register_callback(some_global_func);                     // 函数指针
register_callback(Multiplier{});                         // 函数对象

std::vector<std::function<void()>> tasks;
tasks.push_back([] { /* 任务1 */ });
tasks.push_back([] { /* 任务2 */ });
for (auto& t : tasks) t();

int add(int a, int b) { return a + b; }

// 预绑定第一个参数为 10
auto add10 = std::bind(add, 10, std::placeholders::_1);
add10(5);   // 等价 add(10, 5) = 15

// 重排参数顺序
auto minus = std::bind([](int a, int b) { return a - b; },
                       std::placeholders::_2, std::placeholders::_1);
minus(5, 3);  // 等价 3 - 5 = -2

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

max(1, 2);            // 生成 max(int, int)
max(1.5, 2.5);        // 生成 max(double, double)

// 类模板
template<typename T>
class Stack {
    std::vector<T> elems;
public:
    void push(const T& e) { elems.push_back(e); }
};

Stack<int> si;
Stack<std::string> ss;

// 类型安全 + 高性能：sort 对不同类型生成专用版本
std::vector<int> vi;
std::vector<double> vd;
std::sort(vi.begin(), vi.end());   // 生成 sort<int>
std::sort(vd.begin(), vd.end());   // 生成 sort<double>

// 代码膨胀示意：三个类型 = 三份代码
Stack<int> a;
Stack<double> b;
Stack<std::string> c;
// 编译后生成三份 Stack 的实现

template<typename T>
T add(T a, T b) { return a + b; }

add(1, 2);        // T 自动推导为 int，无需写 <int>
add(1.5, 2.5);    // T 自动推导为 double
add<int>(1, 2);   // 也可以显式指定

template<typename T>
class Box {
    T value;
public:
    Box(T v) : value(v) {}
};

Box<int> b1(10);           // 必须显式指定 <int>（C++17 前）
Box<std::string> b2("hi");
// Box b3(10);             // C++17 CTAD 才支持类模板自动推导

// 函数模板：只能全特化
template<typename T> void func(T t) { /* 通用版 */ }
template<> void func<int>(int t) { /* int 特化版 */ }   // ✅ 全特化
// 函数模板没有偏特化（偏特化需要重载模拟）

// 类模板：支持全特化和偏特化
template<typename T, typename U> class Pair { /* 通用版 */ };
template<typename T> class Pair<T, T> { /* 偏特化：两个参数相同 */ };   // ✅ 偏特化
template<typename T> class Pair<T, int> { /* 偏特化：第二个是 int */ };

// 方式一：函数指针
int add(int a, int b) { return a + b; }
int mul(int a, int b) { return a * b; }

void compute(int x, int y, int (*op)(int, int)) {
    std::cout << "结果: " << op(x, y) << std::endl;
}

compute(3, 4, add);   // 把 add 作为回调传入
compute(3, 4, mul);   // 把 mul 作为回调传入

// 方式二：std::function（更现代、更灵活）
#include <functional>
void compute2(int x, int y, std::function<int(int,int)> op) {
    std::cout << "结果: " << op(x, y) << std::endl;
}
compute2(3, 4, [](int a, int b) { return a - b; });  // 直接传 lambda

// 经典场景：算法库通过回调提供"比较规则"和"判断条件"
std::vector<int> v = {3, 1, 4, 1, 5};
std::sort(v.begin(), v.end(),
          [](int a, int b) { return a > b; });   // 降序：比较逻辑是回调

int target = 3;
auto it = std::find_if(v.begin(), v.end(),
          [target](int x) { return x == target; });  // 查找：判断逻辑是回调

        地址:    0x100  0x101  0x102  0x103
大端序:          0x12   0x34   0x56   0x78   （高字节在前）
小端序:          0x78   0x56   0x34   0x12   （低字节在前）

#include <cstdint>
#include <cstdio>

bool isLittleEndian() {
    uint16_t x = 0x0001;   // 十六进制 1，低字节是 01，高字节是 00
    auto* p = reinterpret_cast<unsigned char*>(&x);
    return p[0] == 0x01;   // 若低地址存的是低字节 → 小端
}

// 或使用 union 技巧
union Endian {
    uint16_t v;
    unsigned char c[2];
};

int main() {
    Endian e{0x0001};
    printf(e.c[0] == 0x01 ? "Little-Endian\n" : "Big-Endian\n");
}

class MyString {
public:
    char* data;
    MyString(const char* s) {
        data = new char[strlen(s) + 1];
        strcpy(data, s);
    }
    ~MyString() { delete[] data; }
    // 没有自定义拷贝构造 → 使用默认的浅拷贝
};

int main() {
    MyString a("hello");
    MyString b = a;   // ❌ 浅拷贝：b.data 和 a.data 指向同一块内存
    // 两个对象析构时都会 delete[] 同一块内存 → double free → 崩溃
}

#include <cstring>

class MyString {
public:
    char* data;
    size_t len;

    // 普通构造函数
    MyString(const char* s) : len(strlen(s)) {
        data = new char[len + 1];
        strcpy(data, s);
    }

    // 拷贝构造函数（深拷贝）—— 标准写法
    MyString(const MyString& other) : len(other.len) {
        data = new char[len + 1];        // ① 重新分配内存
        strcpy(data, other.data);        // ② 复制内容（不是复制指针）
    }

    // 拷贝赋值运算符（深拷贝，配合 Rule of Three）
    MyString& operator=(const MyString& other) {
        if (this != &other) {            // ③ 防止自赋值
            delete[] data;               // ④ 释放旧资源
            len = other.len;
            data = new char[len + 1];    // ⑤ 重新分配
            strcpy(data, other.data);    // ⑥ 复制内容
        }
        return *this;
    }

    ~MyString() { delete[] data; }
};

#include <iostream>

class Box {
private:
    double width;
public:
    Box(double w) : width(w) {}

    // 1. 友元函数：普通函数可以访问私有成员
    friend double getWidth(const Box& b);

    // 2. 友元类：Printer 的所有成员都能访问 Box 的私有成员
    friend class Printer;

    // 3. 友元成员函数：只授权 AnotherClass 的 printWidth 这一个成员
    // friend void AnotherClass::printWidth(const Box& b);
};

double getWidth(const Box& b) {
    return b.width;   // ✅ 友元函数可直接访问私有成员
}

class Printer {
public:
    void print(const Box& b) {
        std::cout << "width = " << b.width << std::endl;  // ✅ 友元类
    }
};

class Complex {
    double real, imag;
public:
    Complex(double r, double i) : real(r), imag(i) {}

    // 流插入运算符重载：作为友元函数，访问私有成员
    friend std::ostream& operator<<(std::ostream& os, const Complex& c) {
        return os << c.real << " + " << c.imag << "i";
    }
};

// main.cpp
#include <iostream>
#define MAX 100

int main() {
    int arr[MAX];               // 预处理后 MAX 被替换为 100
    std::cout << "Hello" << std::endl;  // 调用外部函数，需链接
    return 0;
}

# 1. 预处理（-E）：宏展开、头文件插入
g++ -E main.cpp -o main.i

# 2. 编译（-S）：生成汇编代码
g++ -S main.i -o main.s

# 3. 汇编（-c）：生成目标文件（机器码，符号未解析）
g++ -c main.s -o main.o

# 4. 链接：合并目标文件和库，解析符号，生成可执行文件
g++ main.o -o main