C++基础语法

#include <iostream>                  // 引入标准输入输出头文件
 
int main() {
    bool is_ready = true;            // 声明并初始化一个布尔变量
    bool is_empty = false;           // false 在内存中存储为 0
 
    // bool 参与算术运算时会隐式转换为 int
    int sum = is_ready + is_empty;   // true->1, false->0, sum = 1
    std::cout << sum << std::endl;   // 输出: 1
 
    // 任何非零整数转为 bool 都是 true
    bool from_int = 42;             // 42 != 0, 所以 from_int = true
    bool from_zero = 0;             // 0 -> false
 
    std::cout << std::boolalpha;     // 让 cout 以 "true"/"false" 输出 bool
    std::cout << from_int << std::endl;   // 输出: true
    std::cout << from_zero << std::endl;  // 输出: false
 
    return 0;                        // 程序正常退出
}

#include <iostream>
#include <climits>                   // 包含 CHAR_MIN, CHAR_MAX 等宏
 
int main() {
    char letter = 'A';              // 字符字面量，实际存储 ASCII 码 65
    char newline = '\n';            // 转义字符，存储 ASCII 码 10
 
    // char 本质是整数，可以参与算术运算
    char next = letter + 1;         // 65 + 1 = 66, 即 'B'
    std::cout << next << std::endl; // 输出: B
 
    // 检查当前平台 char 的符号性
    if (CHAR_MIN < 0) {             // CHAR_MIN 定义在 <climits> 中
        std::cout << "char is signed on this platform" << std::endl;
    } else {
        std::cout << "char is unsigned on this platform" << std::endl;
    }
 
    // 当你需要用 char 做"小整数"运算时，请显式指定符号性
    signed char   temperature = -10; // 明确有符号，可存负数
    unsigned char pixel_value = 255; // 明确无符号，用于像素亮度等
 
    return 0;
}

#include <iostream>
#include <cstdint>                   // C++11 定宽整数类型
 
int main() {
    // ========== 传统整型 ==========
    short           s  = -100;       // 等价于 signed short
    unsigned short  us = 60000;      // 无符号 short, 最大 65535 (16-bit)
    int             i  = -200000;    // 最常用的整数类型
    unsigned int    ui = 4000000000; // 约 40 亿, 用于不需要负数的场景
    long            l  = 100000L;    // L 后缀表示 long 字面量
    long long       ll = 9000000000000000000LL; // LL 后缀表示 long long
 
    // ========== 定宽整型 (Fixed-width, C++11) ==========
    int8_t   a = -128;              // 精确 8 位有符号
    uint8_t  b = 255;               // 精确 8 位无符号
    int16_t  c = -32768;            // 精确 16 位有符号
    uint16_t d = 65535;             // 精确 16 位无符号
    int32_t  e = -2147483648;       // 精确 32 位有符号
    uint32_t f = 4294967295;        // 精确 32 位无符号
    int64_t  g = -1;               // 精确 64 位有符号
    uint64_t h = 18446744073709551615ULL; // 精确 64 位无符号, 最大值
 
    std::cout << "int:       " << sizeof(int)       << " bytes\n";  // 通常输出 4
    std::cout << "long:      " << sizeof(long)      << " bytes\n";  // Linux 64-bit: 8, Windows: 4
    std::cout << "long long: " << sizeof(long long) << " bytes\n";  // 通常输出 8
 
    return 0;
}

#include <iostream>
 
int main() {
    int           a = -1;           // 有符号, 值为 -1
    unsigned int  b = 1;            // 无符号, 值为 1
 
    // 比较时 a 被隐式转换为 unsigned int
    // -1 的二进制补码 = 0xFFFFFFFF = 4294967295 (作为 unsigned)
    if (a < b) {                    // 实际比较: 4294967295 < 1 → false!
        std::cout << "-1 < 1" << std::endl;
    } else {
        std::cout << "-1 >= 1 ???" << std::endl;  // 这行会被执行!
    }
 
    // 更隐蔽的例子: vector.size() 返回 size_t (unsigned)
    // for (int i = 0; i < vec.size(); ++i)  ← 如果 vec 为空, 比较也是安全的
    // 但 for (int i = vec.size() - 1; i >= 0; --i) ← 若 vec 为空, size()-1 下溢!
 
    return 0;
}

#include <iostream>
#include <iomanip>                   // std::setprecision
#include <cmath>                     // std::abs
 
int main() {
    // ========== 精度演示 ==========
    float  f = 0.1f;                // float 只有约 7 位有效数字
    double d = 0.1;                 // double 有约 15 位有效数字
 
    std::cout << std::setprecision(20); // 设置输出精度为 20 位
    std::cout << "float  0.1 = " << f << std::endl;  // 0.10000000149011611938
    std::cout << "double 0.1 = " << d << std::endl;  // 0.10000000000000000555
 
    // ========== 经典陷阱: 浮点比较 ==========
    double a = 0.1 + 0.2;           // 数学上应为 0.3
    double b = 0.3;                 // 直接赋值 0.3
 
    if (a == b) {                   // ❌ 几乎永远不要这样比较浮点数!
        std::cout << "equal" << std::endl;
    } else {
        std::cout << "NOT equal!" << std::endl;     // 这行会被执行
        std::cout << "a = " << a << std::endl;      // 0.30000000000000004441
        std::cout << "b = " << b << std::endl;      // 0.29999999999999998890
    }
 
    // ========== 正确做法: epsilon 比较 ==========
    const double epsilon = 1e-9;    // 根据业务精度需求选取阈值
    if (std::abs(a - b) < epsilon) {// 判断差值是否小于容差
        std::cout << "approximately equal ✓" << std::endl; // ✓
    }
 
    return 0;
}

#include <iostream>
#include <cmath>                     // std::isinf, std::isnan
#include <limits>                    // std::numeric_limits
 
int main() {
    double pos_inf = 1.0 / 0.0;     // +∞ (正无穷)
    double neg_inf = -1.0 / 0.0;    // -∞ (负无穷)
    double nan_val = 0.0 / 0.0;     // NaN (Not a Number, 未定义)
 
    std::cout << "1.0/0.0  = " << pos_inf << std::endl;  // inf
    std::cout << "-1.0/0.0 = " << neg_inf << std::endl;  // -inf
    std::cout << "0.0/0.0  = " << nan_val << std::endl;  // nan 或 -nan
 
    // NaN 的独特性质: NaN 不等于任何值, 包括它自己!
    if (nan_val != nan_val) {        // true! 这是检测 NaN 的经典技巧
        std::cout << "NaN != NaN is true" << std::endl;
    }
 
    // 推荐使用标准库函数进行检测
    std::cout << std::boolalpha;
    std::cout << "isinf: " << std::isinf(pos_inf) << std::endl;  // true
    std::cout << "isnan: " << std::isnan(nan_val) << std::endl;  // true
 
    // 获取类型的极限值
    std::cout << "double max: " << std::numeric_limits<double>::max() << std::endl;
    std::cout << "double min: " << std::numeric_limits<double>::min() << std::endl;  // 最小正值
    std::cout << "double epsilon: " << std::numeric_limits<double>::epsilon() << std::endl;
 
    return 0;
}

#include <iostream>
 
void greet() {                       // 返回类型为 void, 无返回值
    std::cout << "Hello!" << std::endl;
    // return;                       // 可以写 return; 但不能 return 值;
}
 
int main() {
    greet();                         // 调用 void 函数
 
    int    x = 42;
    double y = 3.14;
 
    void* ptr = &x;                  // void* 可以指向 int
    // std::cout << *ptr;            // ❌ 编译错误! 不能解引用 void*
    std::cout << *(static_cast<int*>(ptr)) << std::endl; // ✓ 先转换再解引用
 
    ptr = &y;                        // 同一个 void* 现在指向 double
    std::cout << *(static_cast<double*>(ptr)) << std::endl; // 输出 3.14
 
    return 0;
}

#include <iostream>
#include <cstddef>                   // std::nullptr_t
 
void process(int value) {            // 重载版本 1: 接受 int
    std::cout << "int: " << value << std::endl;
}
 
void process(int* ptr) {             // 重载版本 2: 接受 int*
    std::cout << "int*: " << ptr << std::endl;
}
 
int main() {
    // process(NULL);                // ❌ 歧义! NULL 是 0, 匹配 int 还是 int* ?
    process(nullptr);                // ✓ 明确匹配 int* 版本
 
    // nullptr 可以隐式转换为任意指针类型
    int*    p1 = nullptr;            // OK
    double* p2 = nullptr;            // OK
    // int    n  = nullptr;          // ❌ 编译错误! nullptr 不能转为 int
 
    // nullptr_t 类型本身也可以作为参数类型
    // void handle(std::nullptr_t) { ... }  // 只接受 nullptr
 
    return 0;
}

#include <iostream>
 
int main() {
    // ========== 语法形式 1: sizeof(类型) ==========
    std::cout << "bool:        " << sizeof(bool)        << std::endl;  // 通常 1
    std::cout << "char:        " << sizeof(char)        << std::endl;  // 恒为 1（标准规定）
    std::cout << "short:       " << sizeof(short)       << std::endl;  // 通常 2
    std::cout << "int:         " << sizeof(int)         << std::endl;  // 通常 4
    std::cout << "long:        " << sizeof(long)        << std::endl;  // 4 或 8
    std::cout << "long long:   " << sizeof(long long)   << std::endl;  // 通常 8
    std::cout << "float:       " << sizeof(float)       << std::endl;  // 通常 4
    std::cout << "double:      " << sizeof(double)      << std::endl;  // 通常 8
    std::cout << "long double: " << sizeof(long double) << std::endl;  // 8, 12 或 16
 
    // ========== 语法形式 2: sizeof 表达式 (可以不加括号) ==========
    int x = 0;
    std::cout << "sizeof x:    " << sizeof x            << std::endl;  // 等价于 sizeof(int)
 
    // ========== sizeof 不会求值表达式 ==========
    int y = 10;
    std::cout << sizeof(y++)     << std::endl;  // 输出 4, 但 y 仍然是 10!
    std::cout << "y = " << y     << std::endl;  // 输出 10, 未被自增
 
    return 0;
}

#include <iostream>
 
void print_size(int arr[]) {         // 数组退化为指针!
    std::cout << "In function: " << sizeof(arr) << std::endl;  // 指针大小: 4 或 8
}
 
int main() {
    int arr[10];                     // 声明一个含 10 个 int 的数组
    
    // 在声明作用域内, sizeof 返回整个数组的字节数
    std::cout << "Array total: " << sizeof(arr) << std::endl;         // 10 * 4 = 40
    std::cout << "Element:     " << sizeof(arr[0]) << std::endl;      // 4
    
    // 经典技巧: 计算数组元素个数
    std::size_t count = sizeof(arr) / sizeof(arr[0]);                 // 40 / 4 = 10
    std::cout << "Count:       " << count << std::endl;
 
    // 当数组传入函数时, 退化为指针, sizeof 失效
    print_size(arr);                 // 输出 8 (64-bit 系统) 而不是 40!
 
    return 0;
}

#include <iostream>
 
struct Bad {                         // 成员排列不佳的结构体
    char   a;                        // 1 byte  + 3 bytes padding
    int    b;                        // 4 bytes
    char   c;                        // 1 byte  + 3 bytes padding
};                                   // 总计: 12 bytes (而非 6 bytes)
 
struct Good {                        // 成员按大小降序排列
    int    b;                        // 4 bytes
    char   a;                        // 1 byte
    char   c;                        // 1 byte + 2 bytes padding
};                                   // 总计: 8 bytes
 
struct Empty {};                     // 空结构体
 
int main() {
    std::cout << "sizeof(Bad):   " << sizeof(Bad)   << std::endl;  // 12
    std::cout << "sizeof(Good):  " << sizeof(Good)  << std::endl;  // 8
    std::cout << "sizeof(Empty): " << sizeof(Empty) << std::endl;  // 1 (不允许为 0)
 
    return 0;
}

#include <iostream>
 
int main() {
    // sizeof 的结果可以用作数组大小 (需要编译期常量)
    char buffer[sizeof(double)];     // 声明一个和 double 等大的 char 数组
 
    // 可以用在 static_assert 中进行编译期检查
    static_assert(sizeof(int) >= 4, "int must be at least 4 bytes"); // 编译期断言
    static_assert(sizeof(long long) == 8, "long long must be exactly 8 bytes");
 
    // 可以用于模板元编程
    // template<typename T>
    // void func() { char buf[sizeof(T)]; ... }
 
    std::cout << "buffer size: " << sizeof(buffer) << std::endl;  // 8
 
    return 0;
}

#include <iostream>
 
int main() {
    // 整型提升 (Integer Promotion): bool/char/short → int
    char  c = 'A';                   // 'A' = 65
    int   result = c + 1;           // c 被提升为 int, 65 + 1 = 66
    std::cout << static_cast<char>(result) << std::endl;  // 输出: B
 
    // 窄化转换 (Narrowing Conversion): 可能丢失数据
    int    big = 300;
    char   small_val = big;          // ⚠️ 300 超出 char 范围, 截断! 值未定义
    std::cout << static_cast<int>(small_val) << std::endl; // 可能输出 44 (300 % 256)
 
    // C++11 花括号初始化可以阻止窄化转换
    // char safe{300};               // ❌ 编译错误! 窄化转换在 {} 中被禁止
 
    return 0;
}

#include <iostream>
 
int main() {
    double pi = 3.14159;
 
    // static_cast: 最常用, 编译期检查
    int truncated = static_cast<int>(pi);        // 3 (截断小数部分)
    std::cout << truncated << std::endl;
 
    // C 风格转换 (不推荐, 但需要认识)
    int c_style = (int)pi;                       // 等效但不安全
    int func_style = int(pi);                    // 函数风格, 同上
 
    return 0;
}

#include <iostream>
#include <vector>
#include <typeinfo>                  // typeid
 
int main() {
    auto i = 42;                     // int (整数字面量默认为 int)
    auto d = 3.14;                   // double (浮点字面量默认为 double)
    auto f = 3.14f;                  // float (f 后缀指定 float)
    auto c = 'X';                    // char
    auto b = true;                   // bool
    auto ll = 100LL;                 // long long (LL 后缀)
    auto u = 100U;                   // unsigned int (U 后缀)
 
    // auto 在复杂类型中尤其好用
    std::vector<int> vec = {1, 2, 3};
    auto it = vec.begin();           // std::vector<int>::iterator (无需手写冗长类型)
 
    // 输出推导出的类型名（仅做演示，typeid.name() 的输出格式取决于编译器）
    std::cout << "i:  " << typeid(i).name()  << std::endl;
    std::cout << "d:  " << typeid(d).name()  << std::endl;
    std::cout << "it: " << typeid(it).name() << std::endl;
 
    return 0;
}

#include <iostream>
 
struct X {
    char a;
    double b;
    int c;
};
 
int main() {
    int arr[5];
    int* p = arr;
 
    std::cout << sizeof(arr) << " "
              << sizeof(p)   << " "
              << sizeof(X)   << std::endl;
    return 0;
}

// ============ 变量的声明与初始化 ============
 
int a;           // 声明变量 a，未初始化（值不确定，属于 UB: Undefined Behavior）
int b = 10;      // C 风格初始化（拷贝初始化, Copy Initialization）
int c(20);       // 直接初始化（Direct Initialization）
int d{30};       // C++11 列表初始化（List Initialization / Brace Initialization）
int e = {40};    // C++11 拷贝列表初始化（Copy List Initialization）

int x1 = 3.14;   // 合法！但 3.14 被截断为 3，丢失精度（窄化转换）
// int x2{3.14};  // 编译错误！花括号初始化禁止 double -> int 的窄化转换
// int x3 = {3.14}; // 同样编译错误

#include <iostream>
 
int global_var = 100;           // 静态存储期：全局变量，程序开始时初始化
 
void demo() {
    int local_var = 10;         // 自动存储期：进入 demo() 时创建
    static int call_count = 0;  // 静态存储期：仅在第一次调用时初始化
    call_count++;               // 每次调用 demo() 时递增
    std::cout << "Called " << call_count << " times\n";
}                               // local_var 在此处被销毁，call_count 不会
 
int main() {
    demo();  // 输出: Called 1 times
    demo();  // 输出: Called 2 times
    demo();  // 输出: Called 3 times
    return 0;
}

const int kMaxSize = 1024;     // 定义一个整型常量，值为 1024
// kMaxSize = 2048;            // 编译错误！不能修改 const 变量

const double kPi = 3.14159265358979;   // 圆周率，定义后不可修改
const int kBufferSize = 256;           // 缓冲区大小常量
 
// kPi = 3.0;         // 编译错误：assignment of read-only variable
// kBufferSize = 512; // 编译错误

// const int x;   // 编译错误！const 变量必须初始化
const int x = 42; // 正确

int value = 42;
int other = 99;
 
// ---- 情况 1: 指向常量的指针 (Pointer to const) ----
const int* p1 = &value;     // p1 指向的内容不能通过 p1 修改
// *p1 = 100;               // 编译错误：不能通过 p1 修改所指的值
p1 = &other;                // 合法：p1 本身可以指向别处
 
// 等价写法（East const 风格）：
int const* p1_alt = &value;  // 与 const int* 完全等价
 
// ---- 情况 2: 常量指针 (const Pointer) ----
int* const p2 = &value;     // p2 本身不能再指向别处
*p2 = 100;                  // 合法：可以通过 p2 修改所指的值
// p2 = &other;             // 编译错误：p2 本身是 const，不能改指向
 
// ---- 情况 3: 指向常量的常量指针 (const Pointer to const) ----
const int* const p3 = &value; // p3 本身不能改，指向的内容也不能改
// *p3 = 100;               // 编译错误
// p3 = &other;             // 编译错误

#include <string>
#include <iostream>
 
// 传 const 引用：不拷贝、不修改，最安全高效
void print_name(const std::string& name) {
    std::cout << "Hello, " << name << std::endl;
    // name = "hacker";  // 编译错误：不能修改 const 引用
}
 
// 传值：会触发拷贝构造，对大对象有性能开销
void print_name_copy(std::string name) {
    std::cout << "Hello, " << name << std::endl;
}
 
int main() {
    std::string my_name = "Alice";
    print_name(my_name);       // 零拷贝，高效
    print_name_copy(my_name);  // 触发一次 string 拷贝，较慢
    return 0;
}

// int& ref = 42;         // 编译错误：普通引用不能绑定到右值（字面量）
const int& cref = 42;     // 合法！const 引用可以绑定右值，延长临时对象的生命周期
 
const std::string& greeting = std::string("Hello");  // 合法！临时对象生命周期延长

class Circle {
private:
    double radius_;           // 半径
 
public:
    Circle(double r) : radius_(r) {}   // 构造函数
 
    // const 成员函数：承诺不修改任何成员变量
    double area() const {
        // radius_ = 0;      // 编译错误！const 成员函数内不能修改成员
        return 3.14159 * radius_ * radius_;
    }
 
    // 非 const 成员函数：可以修改成员变量
    void set_radius(double r) {
        radius_ = r;          // 合法
    }
};
 
void print_area(const Circle& c) {
    std::cout << c.area() << std::endl;  // 合法：area() 是 const 的
    // c.set_radius(5.0);               // 编译错误：const 对象只能调用 const 函数
}

const int ci = 42;        // 顶层 const
int i = ci;               // 合法：拷贝时顶层 const 被忽略（i 是 ci 值的副本）
 
const int* p1 = &ci;      // 底层 const
// int* p2 = p1;          // 编译错误：底层 const 不能被忽略！
                           // 否则就能通过 p2 修改 ci，破坏 const 语义
const int* p3 = p1;       // 合法：底层 const 一致

constexpr int kMaxThreads = 8;            // 编译期常量，值在编译时确定
constexpr double kPi = 3.14159265358979;  // 编译期浮点常量
constexpr int kDoubled = kMaxThreads * 2; // 编译期计算：结果 16
 
// constexpr int x = some_runtime_func();  // 编译错误！constexpr 变量的初始值
                                            // 必须是编译期可求值的表达式

// constexpr 函数：如果参数是编译期已知的，编译器在编译期就算出结果
constexpr int factorial(int n) {
    return (n <= 1) ? 1 : n * factorial(n - 1);  // 递归计算阶乘
}
 
int main() {
    // 场景 1：编译期求值
    constexpr int f5 = factorial(5);    // 编译期就计算出 120
    static_assert(f5 == 120);           // 编译期断言，通过！
 
    // 场景 2：运行时求值
    int n;
    std::cin >> n;                      // n 是运行时输入
    int fn = factorial(n);              // 此时 factorial 在运行时执行
    return 0;
}

// C++14 及以后：constexpr 函数可以包含循环、局部变量
constexpr int factorial_v2(int n) {
    int result = 1;               // 局部变量
    for (int i = 2; i <= n; ++i)  // 循环
        result *= i;
    return result;
}
 
static_assert(factorial_v2(6) == 720);  // 编译期验证：6! = 720 ✅

#include <iostream>
#include <cstdlib>   // std::rand
 
int get_runtime_value() {
    return std::rand();       // 运行时才能确定的值
}
 
int main() {
    // const 可以用运行时的值初始化
    const int a = get_runtime_value();  // 合法！a 在运行时被赋值，之后不可变
    
    // constexpr 必须用编译期的值初始化
    // constexpr int b = get_runtime_value();  // 编译错误！编译期无法调用 rand()
    constexpr int b = 42;                      // 合法！42 是编译期常量
 
    // 只有 constexpr 能保证用于需要编译期常量的场景
    constexpr int size = 10;
    int arr[size];             // 合法：size 是编译期常量
    
    const int size2 = 10;     // 这个 const 碰巧也是编译期可知的
    int arr2[size2];           // 大多数编译器允许（但严格来说依赖编译器优化）
 
    const int size3 = a;      // size3 的值在运行时确定
    // int arr3[size3];       // 非标准！VLA 在 C++ 中不合法
 
    return 0;
}

// consteval: 强制编译期执行，运行时调用则编译报错
consteval int square(int n) {
    return n * n;                  // 必须在编译期计算
}
 
int main() {
    constexpr int a = square(5);   // 合法：编译期调用，a = 25
    // int x = 5;
    // int b = square(x);         // 编译错误！x 不是编译期常量，
                                   // consteval 函数不允许运行时调用
    return 0;
}

constinit int global_counter = 0;  // 编译期初始化为 0（避免 Static Initialization Order Fiasco）
 
void increment() {
    global_counter++;              // 合法！constinit 不意味着 const
}

const auto user_name = get_user_name();   // 明确表示之后不会修改
const auto config = load_config();         // 加载后只读

// ❌ 不推荐：宏定义没有类型安全、作用域控制
#define MAX_SIZE 1024
 
// ✅ 推荐：constexpr 有类型、有作用域、有调试信息
constexpr int kMaxSize = 1024;

// ✅ 推荐
void process(const std::vector<int>& data);
 
// ❌ 不推荐（触发拷贝）
void process(std::vector<int> data);

#include <mutex>
 
class DataCache {
private:
    mutable std::mutex mutex_;       // mutable：即使在 const 函数中也能加锁
    mutable int access_count_ = 0;   // mutable：记录访问次数（不影响逻辑状态）
    std::vector<int> data_;
 
public:
    // const 成员函数：逻辑上不修改对象
    int get(int index) const {
        std::lock_guard<std::mutex> lock(mutex_);  // 合法：mutex_ 是 mutable 的
        access_count_++;                            // 合法：access_count_ 是 mutable 的
        return data_[index];
    }
};

struct Counter {
    mutable int count = 0;             // mutable 成员
    void increment() const { count++; } // const 函数修改 mutable 成员
};
 
// 如果多个线程同时调用 increment()，即使通过 const 引用，也存在数据竞争！

constexpr int a = 10;          // Line 1
const int b = a * 2;           // Line 2
constexpr int c = b + 1;      // Line 3
int arr[c];                    // Line 4

#include <iostream>
using namespace std;
 
int main() {
    // ========== 整数除法陷阱 ==========
    int a = 7, b = 3;
    int result1 = a / b;          // 结果为 2，不是 2.333...（整数除法直接截断小数部分）
    cout << "7 / 3 = " << result1 << endl;
 
    // 若想得到浮点结果，至少有一个操作数必须是浮点类型
    double result2 = 7.0 / 3;     // 7.0 是 double，触发隐式提升，结果为 2.33333
    double result3 = (double)a / b;// 显式将 a 强转为 double，同样得到 2.33333
    cout << "7.0 / 3 = " << result2 << endl;
    cout << "(double)7 / 3 = " << result3 << endl;
 
    // ========== 取模运算 ==========
    // 取模只能用于整数类型，不能用于浮点数（浮点取模请用 fmod()）
    int mod1 = 7 % 3;             // 结果为 1（7 = 3*2 + 1）
    int mod2 = -7 % 3;            // C++11 起规定：结果符号与被除数一致，结果为 -1
    int mod3 = 7 % -3;            // 结果为 1（符号跟随左操作数 7）
    cout << " 7 % 3 = " << mod1 << endl;   //  1
    cout << "-7 % 3 = " << mod2 << endl;   // -1
    cout << " 7 % -3 = " << mod3 << endl;  //  1
 
    return 0;
}

#include <iostream>
using namespace std;
 
int main() {
    int x = 5;
 
    // ===== 前缀自增 (++x): 先加1，再返回新值 =====
    int a = ++x;    // x 先变成 6，然后 a 拿到 6
    // 此时 x == 6, a == 6
    cout << "++x: x=" << x << ", a=" << a << endl;
 
    // ===== 后缀自增 (x++): 先返回旧值，再加1 =====
    x = 5;          // 重置 x
    int b = x++;    // b 先拿到旧值 5，然后 x 变成 6
    // 此时 x == 6, b == 5
    cout << "x++: x=" << x << ", b=" << b << endl;
 
    // ===== 性能提示 =====
    // 对于内置类型 (int, double 等)，前缀和后缀性能无差异
    // 但对于迭代器等自定义类型，后缀版本需要创建临时拷贝，开销更大
    // 因此养成习惯：不需要旧值时，优先使用前缀形式 ++i
 
    return 0;
}

#include <iostream>
using namespace std;
 
int main() {
    int a = 10, b = 20;
 
    // 基本比较，结果为 bool 类型 (true=1, false=0)
    cout << (a == b) << endl;  // 0 (false)
    cout << (a != b) << endl;  // 1 (true)
    cout << (a <  b) << endl;  // 1 (true)
 
    // ===== 经典陷阱：= 与 == 的混淆 =====
    // if (a = 5)  // 这是赋值！a 被赋值为 5，表达式值为 5，非零即 true
    // if (a == 5)  // 这才是比较！
    // 防御性写法（Yoda Condition）：把常量放左边
    // if (5 == a)  // 若误写成 5 = a，编译器直接报错
 
    // ===== 浮点数比较陷阱 =====
    double x = 0.1 + 0.2;       // 实际存储的是 0.30000000000000004（IEEE 754 精度问题）
    double y = 0.3;
    cout << (x == y) << endl;    // 输出 0 (false)！不相等！
 
    // 正确做法：使用 epsilon 容差比较
    const double EPSILON = 1e-9; // 定义一个极小的容差值
    bool isEqual = (abs(x - y) < EPSILON);  // 差值小于容差就认为相等
    cout << isEqual << endl;     // 输出 1 (true)
 
    return 0;
}

#include <iostream>
using namespace std;
 
int main() {
    // ===== 短路求值的实际应用 =====
    int* ptr = nullptr;           // 空指针
 
    // 安全写法：先检查指针非空，再解引用
    // 如果 ptr 为 nullptr，&& 短路，*ptr 不会被执行，避免崩溃
    if (ptr != nullptr && *ptr > 10) {
        cout << "Value is greater than 10" << endl;
    }
    // 若写成 if (*ptr > 10 && ptr != nullptr)
    // 先解引用空指针 → 程序崩溃 (Segmentation Fault)！
 
    // ===== 短路求值的副作用陷阱 =====
    int count = 0;
    bool flag = false;
    // flag 为 false，&& 短路，++count 不会执行！
    if (flag && ++count) {        // count 仍然是 0
        // ...
    }
    cout << "count = " << count << endl;  // 输出 0，不是 1
 
    return 0;
}

#include <iostream>
using namespace std;
 
int main() {
    // ===== 按位与 (&)：两位都为1才为1 =====
    // 常用于"掩码提取"（Masking），提取某些特定位
    unsigned char a = 0b11001010;  // 202
    unsigned char mask = 0b00001111;// 掩码：提取低4位
    unsigned char low4 = a & mask; // 结果: 0b00001010 = 10
    cout << "Low 4 bits: " << (int)low4 << endl;
 
    // ===== 按位或 (|)：任一位为1就为1 =====
    // 常用于"设置标志位"（Set Flag）
    unsigned char flags = 0b00000000;  // 所有标志位初始为0
    unsigned char FLAG_READ  = 0b00000001;  // 第0位：读权限
    unsigned char FLAG_WRITE = 0b00000010;  // 第1位：写权限
    flags = flags | FLAG_READ;   // 开启读权限 → 0b00000001
    flags = flags | FLAG_WRITE;  // 开启写权限 → 0b00000011
    cout << "Flags: " << (int)flags << endl;  // 3
 
    // ===== 按位异或 (^)：相同为0，不同为1 =====
    // 经典技巧：不借助临时变量交换两个数
    int x = 5, y = 9;
    x = x ^ y;   // x 存储了 x 和 y 的差异信息
    y = x ^ y;   // y 还原为原始 x（5）
    x = x ^ y;   // x 还原为原始 y（9）
    cout << "x=" << x << ", y=" << y << endl;  // x=9, y=5
 
    // ===== 左移 (<<) 和右移 (>>) =====
    int val = 1;
    cout << (val << 3) << endl;  // 1 * 2^3 = 8  （左移n位 = 乘以2^n）
    cout << (16 >> 2) << endl;   // 16 / 2^2 = 4  （右移n位 = 除以2^n）
 
    // 注意：负数右移是算术右移（高位补符号位），这是 implementation-defined
    // 无符号数右移是逻辑右移（高位补0）
 
    return 0;
}

//  按位与 (&) 运算过程：a & mask
//
//    a    =  1 1 0 0 1 0 1 0   (0xCA = 202)
//    mask =  0 0 0 0 1 1 1 1   (0x0F =  15)
//           ─────────────────
//    结果 =  0 0 0 0 1 0 1 0   (0x0A =  10)
//           ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑
//           高4位被清零  低4位被保留
//
//  左移 (<<) 运算过程：3 << 2
//
//    移位前:  0 0 0 0 0 0 1 1   (3)
//                        ↗ ↗
//    移位后:  0 0 0 0 1 1 0 0   (12)
//                       低位补0

#include <iostream>
using namespace std;
 
int main() {
    int a = 10;
 
    a += 5;    // a = a + 5 → a = 15
    a -= 3;    // a = a - 3 → a = 12
    a *= 2;    // a = a * 2 → a = 24
    a /= 4;    // a = a / 4 → a = 6
    a %= 4;    // a = a % 4 → a = 2
    cout << "a = " << a << endl;  // 输出 2
 
    // ===== 赋值运算符的返回值 =====
    // 赋值表达式返回的是被赋值变量的引用
    int x, y, z;
    x = y = z = 100;    // 链式赋值：从右往左执行
    // 等价于: z = 100; y = z; x = y;
    cout << x << " " << y << " " << z << endl;  // 100 100 100
 
    // ===== 复合赋值的微妙优势 =====
    // a += b 比 a = a + b 好在：
    // 1. a 只被求值一次（当 a 是复杂表达式时有意义）
    // 2. 对于自定义类型，可能避免临时对象的产生
    return 0;
}

#include <iostream>
using namespace std;
 
int main() {
    int a = 10, b = 20;
 
    // 基本用法：等价于 if-else
    int maxVal = (a > b) ? a : b;    // a > b 为 false，所以 maxVal = b = 20
    cout << "Max: " << maxVal << endl;
 
    // 嵌套三元运算符（可读性差，不推荐深度嵌套）
    int x = 15;
    string category = (x < 10) ? "small"        // x < 10 ?
                    : (x < 20) ? "medium"        // 否则 x < 20 ?
                    :             "large";        // 都不满足
    cout << "Category: " << category << endl;    // "medium"
 
    // ===== 三元运算符可以作为左值（特殊场景）=====
    int m = 1, n = 2;
    ((m > n) ? m : n) = 100;  // n 被赋值为 100（因为 m > n 为 false，选中 n）
    cout << "m=" << m << ", n=" << n << endl;  // m=1, n=100
 
    return 0;
}

#include <iostream>
using namespace std;
 
int main() {
    // 逗号运算符：依次执行，返回最后一个表达式的值
    int a = (1, 2, 3, 4, 5);   // a = 5（前面的1,2,3,4都被丢弃）
    cout << "a = " << a << endl;
 
    // 最常见的用法：for 循环中同时操作多个变量
    for (int i = 0, j = 10; i < j; ++i, --j) {
        cout << "i=" << i << ", j=" << j << endl;
    }
    // 注意：for 循环初始化部分的逗号不是逗号运算符，是声明分隔符
    // 但递增部分的 ++i, --j 中的逗号是真正的逗号运算符
 
    return 0;
}

#include <iostream>
using namespace std;
 
int main() {
    // ===== 整型提升 (Integral Promotion) =====
    char c = 'A';        // char 类型，值为 65
    int result = c + 1;  // c 被隐式提升为 int，计算 65 + 1 = 66
    cout << result << endl;           // 66
    cout << (char)result << endl;     // 'B'
 
    // ===== 算术转换 (Usual Arithmetic Conversion) =====
    int i = 5;
    double d = 2.5;
    auto sum = i + d;    // int 自动提升为 double，结果为 double 类型 7.5
    // sum 的类型是 double
 
    // ===== 危险的窄化转换 (Narrowing Conversion) =====
    int big = 300;
    char small = big;    // int → char：300 超出 char 范围，发生截断！
    // char 通常为 -128~127 (signed) 或 0~255 (unsigned)
    cout << (int)small << endl;  // 输出 44（300 % 256 = 44）
 
    // C++11 的列表初始化可以防止窄化转换
    // char safe{big};   // 编译错误！列表初始化禁止窄化转换
 
    return 0;
}

#include <iostream>
using namespace std;
 
int main() {
    // ===== static_cast =====
    double pi = 3.14159;
    int intPi = static_cast<int>(pi);   // 显式将 double 转为 int，截断小数
    cout << intPi << endl;              // 3
 
    // ===== const_cast =====
    const int val = 42;
    // int* p = &val;                   // 编译错误：不能将 const int* 赋给 int*
    int* p = const_cast<int*>(&val);    // 移除 const，编译通过
    // *p = 100;                        // 未定义行为！原始对象是 const，修改它是 UB
 
    // ===== reinterpret_cast =====
    long addr = 0x7FFF12345678;
    int* fakePtr = reinterpret_cast<int*>(addr); // 将整数解释为指针地址
    // 极其危险，仅在与硬件/OS交互等极端场景使用
 
    return 0;
}

#include <iostream>
using namespace std;
 
int main() {
    // ===== 陷阱 1：位运算 vs 关系运算 =====
    int x = 5;
    // 程序员本意：先按位与，再比较
    if (x & 0x01 == 0) {         // 实际执行：x & (0x01 == 0) → x & 0 → 0
        cout << "Even" << endl;  // 永远打印不出来！
    }
    // 正确写法：加括号
    if ((x & 0x01) == 0) {       // 先算 x & 0x01，再和 0 比较
        cout << "Even" << endl;
    }
 
    // ===== 陷阱 2：移位 vs 加法 =====
    int a = 1 << 2 + 3;          // 实际执行：1 << (2 + 3) = 1 << 5 = 32
    // 程序员可能期望：(1 << 2) + 3 = 4 + 3 = 7
    cout << "a = " << a << endl; // 32
 
    // ===== 陷阱 3：三元运算符 vs 赋值 =====
    int m = 0, n = 1;
    // m = n > 0 ? 10 : 20;     // 正确，等价于 m = ((n > 0) ? 10 : 20)
    // 但：cout << (n > 0 ? "yes" : "no") << endl; 一定加括号，避免歧义
 
    return 0;
}

#include <iostream>
using namespace std;
 
int main() {
    // sizeof 是运算符，不是函数！
    // 对类型使用必须加括号，对变量/表达式可以不加
    int arr[10];
    cout << sizeof(int) << endl;     // 对类型：必须加括号
    cout << sizeof arr << endl;      // 对变量：可以不加括号（但建议统一加）
    cout << sizeof(arr) << endl;     // 加括号也可以
 
    // sizeof 在编译期求值，不会真正执行表达式
    int x = 5;
    cout << sizeof(x++) << endl;     // 输出 4（int 的大小），但 x 仍然是 5！
    cout << "x = " << x << endl;    // 仍然是 5，x++ 并未真正执行
 
    // 经典用法：计算数组元素个数
    int data[] = {10, 20, 30, 40, 50};
    int count = sizeof(data) / sizeof(data[0]);  // 20 / 4 = 5
    cout << "Array size: " << count << endl;
    // 注意：当数组退化为指针时（如传入函数后），此方法失效！
 
    return 0;
}

#include <iostream>
using namespace std;
int main() {
    int a = 3, b = 5;
    int c = a | b;
    int d = a ^ b;
    int e = a & b;
    cout << c << " " << d << " " << e << endl;
    return 0;
}

int x = 10;
int y = (x > 5) ? (x++, x * 2) : (x--, x / 2);

if (condition) {
    // condition 为 true 时执行
}

#include <iostream>
 
int main() {
    int score = 85;                          // 定义一个分数变量
 
    if (score >= 90) {                       // 条件1：分数 >= 90
        std::cout << "优秀" << std::endl;    // 满足条件1时输出
    } else if (score >= 80) {                // 条件2：分数 >= 80（且 < 90）
        std::cout << "良好" << std::endl;    // 满足条件2时输出
    } else if (score >= 60) {                // 条件3：分数 >= 60（且 < 80）
        std::cout << "及格" << std::endl;    // 满足条件3时输出
    } else {                                 // 以上条件都不满足
        std::cout << "不及格" << std::endl;  // 兜底输出
    }
 
    return 0;                                // 程序正常退出
}

#include <iostream>
#include <map>
#include <string>
 
int main() {
    std::map<std::string, int> scores = {    // 创建一个 map 容器
        {"Alice", 95},                       // 键值对：名字 -> 分数
        {"Bob", 82}
    };
 
    // C++17: init-statement 写在 if 内部
    // it 的作用域被限制在整个 if-else 块中
    if (auto it = scores.find("Alice"); it != scores.end()) {
        // find 返回迭代器，若找到则不等于 end()
        std::cout << "找到了: " << it->second << std::endl;  // 输出分数
    } else {
        // it 在 else 分支中依然可用
        std::cout << "未找到" << std::endl;
    }
    // 出了 if-else 块，it 已不可访问，作用域干净
 
    return 0;
}

// C++11/14 的写法：it 泄漏到外部作用域
auto it = scores.find("Alice");              // it 在这里声明
if (it != scores.end()) {
    std::cout << it->second << std::endl;
}
// it 在这里仍然存在，可能被误用

#include <iostream>
#include <type_traits>                       // 引入类型特征库
 
template <typename T>
void printTypeInfo(const T& val) {
    if constexpr (std::is_integral_v<T>) {   // 编译期判断：T 是否为整数类型
        // 仅当 T 是整数类型时，这段代码才会被编译
        std::cout << val << " 是整数类型" << std::endl;
    } else if constexpr (std::is_floating_point_v<T>) {
        // 仅当 T 是浮点类型时编译
        std::cout << val << " 是浮点类型" << std::endl;
    } else {
        // 其他类型
        std::cout << "其他类型" << std::endl;
    }
}
 
int main() {
    printTypeInfo(42);                       // T = int，走整数分支
    printTypeInfo(3.14);                     // T = double，走浮点分支
    printTypeInfo("hello");                  // T = const char*，走 else 分支
    return 0;
}

// 危险示例 —— 没有花括号
if (x > 0)
    if (y > 0)
        std::cout << "x>0 且 y>0";
else                                         // 这个 else 实际上属于内层 if (y>0)
    std::cout << "这不是 x<=0 的分支！";     // 容易误解为外层 else

// 安全写法 —— 永远使用花括号
if (x > 0) {
    if (y > 0) {
        std::cout << "x>0 且 y>0";
    }
} else {
    std::cout << "x<=0";                     // 现在语义明确
}

switch (expression) {                        // expression 必须是整型或枚举类型
    case constant1:                          // 若 expression == constant1
        // 执行语句
        break;                               // 跳出 switch
    case constant2:
        // 执行语句
        break;
    default:                                 // 所有 case 都不匹配时执行
        // 兜底逻辑
        break;
}

#include <iostream>
 
int main() {
    int day = 3;                             // 用数字表示星期
 
    switch (day) {                           // 根据 day 的值跳转
        case 1:                              // day == 1
            std::cout << "Monday" << std::endl;
            break;                           // 必须 break，否则会 fall-through
        case 2:                              // day == 2
            std::cout << "Tuesday" << std::endl;
            break;
        case 3:                              // day == 3
            std::cout << "Wednesday" << std::endl;
            break;
        case 4:                              // day == 4
            std::cout << "Thursday" << std::endl;
            break;
        case 5:                              // day == 5
            std::cout << "Friday" << std::endl;
            break;
        case 6:                              // fall-through: 6 和 7 共享逻辑
        case 7:                              // day == 6 或 day == 7
            std::cout << "Weekend!" << std::endl;
            break;
        default:                             // 无匹配项
            std::cout << "Invalid day" << std::endl;
            break;                           // default 末尾的 break 虽非必须，但推荐加上
    }
 
    return 0;
}

switch (level) {
    case 3:                                  // level == 3
        applyGoldBonus();                    // 金牌加成
        [[fallthrough]];                     // 显式声明：故意穿透
    case 2:                                  // level == 2（或从 3 穿透而来）
        applySilverBonus();                  // 银牌加成
        [[fallthrough]];                     // 再次显式声明
    case 1:                                  // level == 1（或从上方穿透而来）
        applyBasicBonus();                   // 基础加成
        break;                               // 最终跳出
    default:
        break;
}

switch (x) {
    case 1:
        int val = 10;                        // 错误！跳转到 case 2 时会跳过此初始化
        break;
    case 2:
        std::cout << val;                    // val 可能未被初始化
        break;
}

switch (x) {
    case 1: {                                // 花括号创建独立作用域
        int val = 10;                        // val 的作用域仅限于此 case 块
        std::cout << val << std::endl;
        break;
    }
    case 2: {
        int val = 20;                        // 另一个独立的 val，互不冲突
        std::cout << val << std::endl;
        break;
    }
}

for (init; condition; update) {
    // 循环体
}

#include <iostream>
 
int main() {
    // 经典用法：打印 0 到 4
    for (int i = 0; i < 5; ++i) {            // i 从 0 开始，每次 +1，直到 i >= 5
        std::cout << i << " ";               // 输出当前 i 的值
    }
    // 输出: 0 1 2 3 4
    std::cout << std::endl;
 
    // 多变量初始化：同时控制两个迭代器
    for (int lo = 0, hi = 10; lo < hi; ++lo, --hi) {
        // lo 从 0 递增，hi 从 10 递减，两者相遇时停止
        std::cout << "[" << lo << "," << hi << "] ";
    }
    // 输出: [0,10] [1,9] [2,8] [3,7] [4,6]
    std::cout << std::endl;
 
    // 省略三段式的任意部分（甚至全部）
    // 无限循环：for (;;) 等价于 while (true)
    int count = 0;                           // 初始化放到外面
    for (;;) {                               // 三段全部省略 = 无限循环
        if (count >= 3) break;               // 手动退出条件
        std::cout << count << " ";
        ++count;
    }
    // 输出: 0 1 2
 
    return 0;
}

for (declaration : range_expression) {
    // 使用 declaration 访问每个元素
}

#include <iostream>
#include <vector>
#include <string>
 
int main() {
    std::vector<int> nums = {10, 20, 30, 40, 50};  // 创建整型向量
 
    // 值拷贝遍历：elem 是每个元素的副本
    for (int elem : nums) {                  // elem 依次取 10, 20, 30, 40, 50
        std::cout << elem << " ";            // 修改 elem 不影响原容器
    }
    std::cout << std::endl;
 
    // 引用遍历：可以修改原容器中的元素
    for (int& elem : nums) {                 // elem 是原始元素的引用
        elem *= 2;                           // 将容器中每个元素翻倍
    }
    // 此时 nums = {20, 40, 60, 80, 100}
 
    // const 引用遍历：只读 + 避免拷贝开销（推荐用于大对象）
    for (const auto& elem : nums) {          // auto 自动推导类型，const 防止修改
        std::cout << elem << " ";
    }
    std::cout << std::endl;
 
    // 遍历初始化列表（C++11）
    for (const auto& s : {"hello", "world", "C++"}) {
        std::cout << s << " ";               // 输出: hello world C++
    }
    std::cout << std::endl;
 
    return 0;
}