1.1 核心基本类型#

原理: 当你声明一个变量时（如 int a;），编译器会在内存中预留一块与该类型大小相匹配的空间（int通常是4字节）。变量名a就成了这块内存空间的别名，你可以通过它来读写这块内存。

1.2 类型修饰符与高级主题#

修饰符可以改变基本类型的特性。

• signed / unsigned:

  • 介绍: unsigned 只能表示非负整数，但其正数表示范围是对应signed类型的两倍。整型默认为signed。
  • 示例 (常见陷阱):

    1
    unsigned int a = 5;
    2
    int b = -10;
    3
    
    4
    // 警告：当有符号和无符号整数混合运算时，有符号数会被隐式转换为无符号数。
    5
    // -10 会被转换成一个非常大的正整数，导致比较结果与直觉相反。
    6
    if (a + b > 0) {
    7
        // 这个分支会被执行！
    8
        std::cout << "5 + (-10) > 0 is true because of implicit conversion." << std::endl;
    9
    }
    

  • 注意事项: 强烈建议避免 signed 和 unsigned 类型的混合运算。应使用 unsigned 类型（如 size_t）来表示数量、大小或索引等永远不会为负的值。

• const (常量):

  • 介绍: const 关键字用于声明一个其值在初始化后不能被修改的实体。
  • 多样化示例:

    1
    const double PI = 3.14159; // 常量，不能修改
    2
    
    3
    int value = 10;
    4
    // 指向常量的指针：不能通过指针修改值
    5
    const int* ptr_to_const = &value;
    6
    // *ptr_to_const = 20; // 编译错误!
    7
    
    8
    // 常量指针：指针自身的指向不能改变
    9
    int* const const_ptr = &value;
    10
    *const_ptr = 25; // 合法，可以修改指向的值
    11
    // const_ptr = &another_value; // 编译错误!
    12
    
    13
    // 指向常量的常量指针：指针的指向和指向的值都不能改变
    14
    const int* const const_ptr_to_const = &value;
    

• volatile (易变):

  • 介绍: 告知编译器，变量的值可能在程序代码的控制之外被意外更改（例如由硬件或另一线程）。这会阻止编译器对该变量的访问进行优化。
  • 示例 (概念):

    1
    // 假设这是一个由硬件实时更新的状态寄存器地址
    2
    volatile unsigned int* hardware_status = (unsigned int*)0x12345678;
    3
    while (*hardware_status == 0) {
    4
        // 等待硬件准备就绪。若无 volatile，编译器可能优化掉这个循环。
    5
    }
    

1.3 现代C++中的字符类型#

为了更好地支持Unicode，C++11及以后版本引入了新的字符类型。

• char8_t (C++20), char16_t, char32_t:
  • 介绍: 分别用于存储UTF-8, UTF-16, 和 UTF-32 编码的字符。
  • 示例:

    1
    const char8_t* utf8_str = u8"你好，世界！"; // u8前缀
    2
    const char16_t* utf16_str = u"你好";       // u前缀
    3
    const char32_t* utf32_str = U"世界";       // U前缀
    

2.1 数组 (Array)#

• 介绍: 存储在连续内存位置的相同类型元素的集合。
• 多样化示例:

  1
  // 一维C风格数组
  2
  int scores[] = {98, 87, 92, 79, 85};
  3
  scores[0] = 100; // 修改第一个元素
  4
  
  5
  // 二维数组 (矩阵)
  6
  int matrix[2][3] = { {1, 2, 3}, {4, 5, 6} };
  7
  std::cout << matrix[1][2] << std::endl; // 输出 6
  

• 注意事项: C风格数组在传递给函数时会“退化”为指针，丢失大小信息，且容易发生越界访问。
• 现代C++替代方案:
  • std::array: 固定大小的数组封装，更安全，接口更友好。
  • std::vector: 动态数组，大小可在运行时改变，是C++中最常用的容器之一。

  1
  #include <array>
  2
  #include <vector>
  3
  
  4
  std::array<int, 3> std_array = {1, 2, 3};
  5
  std::cout << "std::array size: " << std_array.size() << std::endl;
  6
  
  7
  std::vector<int> std_vector = {4, 5, 6};
  8
  std_vector.push_back(7); // 动态添加元素
  9
  std::cout << "std::vector element at(1): " << std_vector.at(1) << std::endl; // at()会进行边界检查
  

2.2 指针 (Pointer)#

• 介绍: 指针是一个变量，其值为另一个变量的内存地址。
• 原理: 指针存储一个地址。通过解引用操作符 *，可以访问该地址处存储的值。
• 多样化示例:

  1
  // 基本用法
  2
  int var = 20;
  3
  int* ptr = &var;
  4
  *ptr = 30; // 通过指针修改var的值
  5
  std::cout << var << std::endl; // 输出 30
  6
  
  7
  // 函数指针：指向函数的指针
  8
  void say_hello() { std::cout << "Hello!" << std::endl; }
  9
  void (*func_ptr)() = &say_hello;
  10
  func_ptr(); // 调用函数，输出 "Hello!"
  11
  
  12
  // 指针的指针：用于在函数内修改一个指针
  13
  void allocate_memory(int** p) { *p = new int(100); }
  14
  int* my_ptr = nullptr;
  15
  allocate_memory(&my_ptr); // 传递指针的地址
  16
  std::cout << *my_ptr << std::endl; // 输出 100
  17
  delete my_ptr;
  

• 注意事项: 务必处理空指针和悬挂指针。使用 new/new[] 分配的内存必须用 delete/delete[] 释放，否则会导致内存泄漏。在现代C++中，应优先使用智能指针 (std::unique_ptr, std::shared_ptr)来自动管理内存。

2.3 引用 (Reference)#

• 介绍: 引用是一个已存在变量的别名。它必须在声明时初始化，且一旦绑定不能再更改。
• 实战对比 (函数参数):

  1
  void by_value(int val) { val++; } // 1. 值传递：不改变原始变量
  2
  void by_pointer(int* ptr) { (*ptr)++; } // 2. 指针传递：改变原始变量
  3
  void by_reference(int& ref) { ref++; } // 3. 引用传递：改变原始变量，语法更简洁
  4
  
  5
  int x = 10, y = 10, z = 10;
  6
  by_value(x);
  7
  by_pointer(&y);
  8
  by_reference(z);
  9
  // 结果: x=10, y=11, z=11
  

• 注意事项:
  • 引用不能为空 (nullptr)。
  • 函数不应返回局部变量的引用。
  • 对于大型对象，使用**常量引用 (const T&)**作为函数参数可以避免昂贵的复制开销，同时保证函数不会修改该对象。

3.1 结构体 (struct) 与 类 (class)#

• 介绍: 两者都允许将不同类型的数据成员和操作这些数据的成员函数封装在一起。主要区别在于 struct 的成员默认是 public，而 class 的成员默认是 private。
• 实践示例 (Class):

  1
  #include <string>
  2
  #include <iostream>
  3
  
  4
  class Student {
  5
  private: // 封装数据，保护其不被外部直接修改
  6
      std::string name;
  7
      int age;
  8
  
  9
  public:
  10
      // 构造函数：在创建对象时初始化
  11
      Student(const std::string& n, int a) : name(n), age(a) {
  12
          std::cout << "Student " << name << " is created." << std::endl;
  13
      }
  14
  
  15
      // 析构函数：在对象销毁时自动调用，用于清理资源
  16
      ~Student() {
  17
          std::cout << "Student " << name << " is destroyed." << std::endl;
  18
      }
  19
  
  20
      // 公有方法：提供与对象交互的安全接口
  21
      void print_info() const { // const 成员函数，保证不修改对象状态
  22
          std::cout << "Name: " << name << ", Age: " << age << std::endl;
  23
      }
  24
  };
  25
  
  26
  int main() {
  27
      Student s1("Alice", 20);
  28
      s1.print_info();
  29
  } // s1 在此处离开作用域，其析构函数被自动调用
  

3.2 联合体 (Union)#

• 介绍: 一种特殊的数据结构，所有成员共享同一块内存空间。任何时候只能有效地存储和访问其中一个成员。
• 场景示例 (带类型标签):

  1
  struct Variant {
  2
      enum Type { INT, FLOAT };
  3
      Type type; // 标记当前存储的是哪种类型
  4
      union {
  5
          int i;
  6
          float f;
  7
      } data;
  8
  };
  9
  
  10
  Variant v;
  11
  v.type = Variant::FLOAT;
  12
  v.data.f = 99.9f;
  

• 注意事项: 手动管理联合体类型容易出错。在C++17及以后版本，应优先使用类型安全的 std::variant。

3.3 枚举 (Enumeration)#

• 介绍: 一种由一组命名的整型常量组成的类型，可增强代码的可读性。
• 现代C++用法 (enum class):

  1
  // 作用域枚举 (enum class) 更安全，避免了命名冲突和隐式转换
  2
  enum class TrafficLight { RED, YELLOW, GREEN };
  3
  
  4
  void take_action(TrafficLight light) {
  5
      switch (light) {
  6
          case TrafficLight::RED: std::cout << "Stop!" << std::endl; break;
  7
          case TrafficLight::YELLOW: std::cout << "Caution!" << std::endl; break;
  8
          case TrafficLight::GREEN: std::cout << "Go!" << std::endl; break;
  9
      }
  10
  }
  11
  
  12
  int main() {
  13
      TrafficLight current_light = TrafficLight::GREEN;
  14
      take_action(current_light);
  15
  }