## 一、C/C++ 基本类型与类

### 1. 基本类型在不同语言中的定位

|类型|C|C++|Python|
|---|---|---|---|
|`int`/`double`|基本类型|基本类型|类（一切皆对象）|
|`string`|`char[]`（非类）|`std::string`（类）|`str` 类|
|`bool`|`_Bool`/`int`（非类）|`bool`（基本类型）|`bool` 类（`int` 子类）|

**核心结论**：

- C/C++ 区分基本类型和类，追求性能与底层控制。
    
- Python 一切皆对象，统一用类封装。
    

---

## 二、结构体与 typedef

### 1. `typedef struct` 的用法

c

typedef struct Student {
    int id;
    char name[20];
} student;  // student 是类型别名

- **`Student`**：结构体标签（struct tag）
    
- **`student`**：typedef 定义的类型别名
    
- **变量声明方式**：
    
    - `struct Student a;` ✅（用标签）
        
    - `student b;` ✅（用别名）
        
    - `Student c;` ❌（`Student` 不是类型名）
        

### 2. 同时定义类型和变量

c

typedef struct {
    int id;
    char name[20];
} Student, student1, student2;

- `Student`：类型别名
    
- `student1`、`student2`：**全局变量**（不是类型名！）
    
- ⚠️ 容易混淆，不推荐
    

### 3. 推荐写法

c

typedef struct {
    int id;
    char name[20];
} Student;
Student stu1;  // 清晰简洁

---

## 三、枚举（enum）

c

enum color { red, green, blue } c;
c = blue;

- **`c` 的类型**：
    
    - C：`enum color`（独立类型，底层是 `int`）
        
    - C++：`color`（普通 enum）或 `Color`（enum class）
        
- **`red`/`green`/`blue`**：整型常量（默认 0,1,2），**不是字符串**
    
- **C++11 `enum class`**：强类型，与整数完全隔离
    

---

## 四、迭代器分类

|迭代器类型|用途|类比|
|---|---|---|
|**输入迭代器**|**读**|数据输入到程序（如 `cin`）|
|**输出迭代器**|**写**|数据从程序输出（如 `cout`）|

**记忆口诀**：输入=读，输出=写（从程序视角看数据流向）

---

## 五、vector 的 reserve vs resize

|特性|`reserve(n)`|`resize(n)`|
|---|---|---|
|影响 `size()`|❌ 不变|✅ 改变|
|影响 `capacity()`|✅ 可能扩容|❌ 通常不变|
|操作对象|不构造/销毁元素|构造或销毁元素|
|用途|优化性能，避免扩容|直接修改元素数量|

**关键区别**：

- `reserve`：只分配内存，不创建对象
    
- `resize`：真正创建/销毁对象
    

---

## 六、list 是链表还是列表？

|语言|`list` 的实现|
|---|---|
|C++ `std::list`|**双向链表**|
|Python `list`|**动态数组**|
|Java `LinkedList`|双向链表|
|Java `ArrayList`|动态数组|

**选择依据**：

- 频繁插入/删除 → 链表
    
- 快速随机访问 → 动态数组
    

---

## 七、指针数组 vs 数组指针

|声明|含义|类型|
|---|---|---|
|`int *ptr[N]`|指针数组|数组，元素是 `int*`|
|`int (*ptr)[N]`|数组指针|指针，指向 `int[N]`|

**记忆口诀**：

- 有括号先结合 `*`（指针）
    
- 无括号先结合 `[]`（数组）
    

### 多维数组传参

- **正确**：`int (*ptr)[N]`（数组指针）
    
- **错误**：`int **ptr`（指针的指针，内存布局不兼容）
    

**原因**：静态二维数组内存连续，退化为指向数组的指针；`int**` 是完全不同的指针结构。

---

## 八、拷贝构造函数

### 触发时机

cpp

void display(Line obj) { ... }  // 按值传递
display(line);  // 调用拷贝构造函数

### 按值传递 vs 按引用传递

|特性|`Line obj`|`const Line &obj`|
|---|---|---|
|拷贝构造|✅ 调用|❌ 不调用|
|内存开销|可能高|无|
|适用场景|需要独立副本|只读操作/大对象|

**最佳实践**：默认用 `const &`，仅在需要副本时用按值传递。

---

## 九、运算符重载 `+=`

### 两种形式

cpp

// 成员函数形式
className& className::operator+=(className& right) {
    return (*this) = (*this) + right;
}
// 非成员函数形式
className& operator+=(className& left, className& right) {
    return left = left + right;
}

**两者都可以**，编译器根据调用形式自动选择。

- 成员函数：`A += B` → `A.operator+=(B)`
    
- 非成员函数：`A += B` → `operator+=(A, B)`
    

**选择建议**：优先用成员函数，需要对称性或特殊类型转换时用非成员。

---

## 十、向上转型 vs 向下转型

|场景|是否允许|原因|
|---|---|---|
|派生类指针 → 基类指针|✅ 允许（隐式）|派生类"是一个"基类，内存布局兼容|
|基类指针 → 派生类指针|❌ 禁止（需显式转换）|基类可能不包含派生类成员，类型不安全|

**安全做法**：用 `dynamic_cast` + 检查返回值。

**要求**：基类必须有虚函数（通常虚析构函数），以支持 RTTI。

---

## 十一、日程安排（多重继承+重载）实战

### 关键点

1. **多重继承**：`Schedule : public Date, public Time`
    
2. **运算符重载**：`operator<` 按年月日时分秒逐级比较
    
3. **动态数组**：用 `vector` 而非原生数组（数量未知、自动扩容、STL 算法支持）
    
4. **常见错误**：
    
    - `Schedule a[] = new Schedule(10);` ❌
        
    - `a[i] = {flag, y, mo, d, h, mi, s};` ❌
        
    - 正确：`a[i] = Schedule(flag, y, mo, d, h, mi, s);`
        

---

## 十二、汽车收费系统（多态实战）

cpp

class Vehicle {
protected:
    string NO;
public:
    virtual void display() = 0;
};
class Car : public Vehicle {
    // 收费：载客数*8 + 重量*2
};
class Truck : public Vehicle {
    // 收费：重量*5
};
class Bus : public Vehicle {
    // 收费：载客数*3
};

**核心**：基类指针数组 `Vehicle *pv[10]`，通过虚函数实现多态。

---

## 十三、容器类层次结构（抽象类实战）

cpp

class Container {
protected:
    static double pi;
public:
    virtual double area() = 0;
    virtual double volume() = 0;
    static double sumofarea(Container *c[], int n);
    static double sumofvolume(Container *c[], int n);
};

- **Cube**：表面积 `6*side²`，体积 `side³`
    
- **Cylinder**：表面积 `2πr² + 2πrh`，体积 `πr²h`
    

---

## 十四、类模板外定义成员函数

### 核心规则

- `template <...>` 的模板参数必须与类模板声明**完全一致**（数量、类型、名称、顺序）。
    
- 类名后的模板参数（如 `Stack<T>`）必须与声明对应。
    

### 示例

cpp

// 类模板声明
template <typename T1, typename T2>
class MyClass {
public:
    void foo(T1 a, T2 b);
};
// 类外定义（必须完整声明）
template <typename T1, typename T2>
void MyClass<T1, T2>::foo(T1 a, T2 b) {
    // 实现
}

### 常见错误

- 参数名不一致：`template <typename U, typename V>` ❌
    
- 参数顺序调换：`template <typename T2, typename T1>` ❌
    
- 缺少模板声明：`void MyClass<T1,T2>::foo()` ❌
    

---

## 总结

| 主题             | 核心结论                        |
| -------------- | --------------------------- |
| 基本类型           | C/C++ 区分基本类型和类，Python 一切皆对象 |
| struct/typedef | 区分标签、别名、变量名                 |
| enum           | 整型常量的命名集合，不是字符串             |
| 迭代器            | 输入=读，输出=写                   |
| reserve/resize | 前者只分配内存，后者修改元素数量            |
| list           | C++ 是链表，Python 是动态数组        |
| 指针数组/数组指针      | 看括号优先级                      |
| 拷贝构造           | 按值传递触发，按引用不触发               |
| 运算符重载          | 成员/非成员均可，优先成员               |
| 向上/向下转型        | 向上安全，向下需 dynamic_cast       |
| 多重继承           | 注意构造顺序和运算符重载                |
| 多态             | 基类指针 + 虚函数                  |
| 类模板            | 类外定义必须完整声明模板参数              |