1
虚函数表(vtable)机制——多态的底层实现:
2

3
class Base {             class Derived : public Base {
4
  virtual void foo();      void foo() override;  // 覆盖
5
  virtual void bar();      void baz();            // 新增
6
};                       };
7

8
  Base对象内存:           Derived对象内存:
9
  ┌──────────┐            ┌──────────┐
10
  │ vptr ────┼──→ vtable  │ vptr ────┼──→ vtable(Derived)
11
  │ 成员变量  │    ┌──────┐│ Base成员  │    ┌──────────────┐
12
  └──────────┘    │foo()→│└──────────┘    │foo()→Derived::foo│
13
                  │bar()→│  Derived成员    │bar()→Base::bar   │
14
                  └──────┘                └──────────────────┘
15

3 collapsed lines
16
  Base *p = new Derived();
17
  p->foo();  // 查vtable → 调用 Derived::foo() (多态!)
18
  p->bar();  // 查vtable → 调用 Base::bar()

1
  ┌──────────────┬────────────────┬────────────────┬───────────────┐
2
  │              │ unique_ptr     │ shared_ptr     │ weak_ptr      │
3
  ├──────────────┼────────────────┼────────────────┼───────────────┤
4
  │ 所有权       │ 独占           │ 共享(引用计数) │ 不拥有        │
5
  │ 拷贝         │ ✗ 不可拷贝    │ ✓ 拷贝时+1    │ ✓             │
6
  │ 移动         │ ✓ 转移所有权  │ ✓              │ ✓             │
7
  │ 开销         │ 零(和裸指针同)│ 引用计数(原子) │ 引用计数      │
8
  │ 循环引用     │ 不会          │ 会!(内存泄漏) │ ★打破循环    │
9
  │ 适用场景     │ 大多数情况★  │ 多处共享一个对象│ 观察者/缓存   │
10
  │ 嵌入式       │ ★推荐        │ 慎用(原子开销)│ 少用          │
11
  └──────────────┴────────────────┴────────────────┴───────────────┘
12

13
  选择策略:
14
    默认用 unique_ptr → 需要共享时 shared_ptr → 打破循环用 weak_ptr

1
// 拷贝 vs 移动:
2
String a("hello");
3
String b = a;              // 拷贝构造: 分配新内存 + memcpy
4
String c = std::move(a);   // 移动构造: 偷走a的指针, a变空
5
                            // 极快! 只是指针赋值,没有内存分配
6

7
// 完美转发(面试加分):
8
template<typename T>
9
void wrapper(T&& arg) {                    // 万能引用
10
    real_func(std::forward<T>(arg));        // 完美转发
11
}
12
// T&&不是"右值引用", 而是"万能引用"(模板+&&)
13
// forward保持原来的左/右值属性不变

1
// C 风格
2
struct Car {
3
    int speed;
4
    int fuel;
5
};
6
void car_accelerate(struct Car *c) { c->speed += 10; }
7

8
// C++ 风格
9
class Car {
10
    int speed;
11
    int fuel;
12
public:
13
    void accelerate() { speed += 10; }  // 数据和操作绑定在一起
14
};

1
// C 语言中
2
struct Point {
3
    int x, y;           // 只能有变量
4
    // void print() {}  ← C中不允许！
5
};
6
struct Point p1;        // C 中必须带 struct 关键字
7

8
// C++ 中
9
struct Point {
10
    int x, y;
11
    void print() { printf("(%d,%d)\n", x, y); }  // 可以有函数
12
    Point(int a, int b) : x(a), y(b) {}           // 可以有构造函数
13
};
14
Point p1(3, 4);        // C++ 中不需要 struct 关键字

1
int a = 10;
2
int &ref = a;   // ref 是 a 的别名，ref 和 a 是同一个东西
3
ref = 20;       // 等同于 a = 20
4
printf("%d\n", a);  // 输出 20
5

6
// int &ref2;   // 错误！引用必须初始化
7
// int &ref3 = NULL; // 错误！引用不能为空

1
void swap(int &a, int &b) {   // 引用传参
2
    int tmp = a; a = b; b = tmp;
3
}
4
int x = 1, y = 2;
5
swap(x, y);  // 调用时不需要取地址，更直观

1
// C++ 允许同名函数，参数不同
2
int add(int a, int b) { return a + b; }
3
double add(double a, double b) { return a + b; }
4
int add(int a, int b, int c) { return a + b + c; }
5

6
add(1, 2);       // 调用第一个 int 版本
7
add(1.5, 2.5);   // 调用第二个 double 版本
8
add(1, 2, 3);    // 调用第三个三参数版本

1
// 在 C++ 文件中调用 C 写的函数
2
extern "C" {
3
    void uart_init(int baud);      // 这个函数是 C 写的
4
    int gpio_read(int pin);
5
}
6

7
// 或者在头文件中（同时兼容 C 和 C++）
8
#ifdef __cplusplus
9
extern "C" {
10
#endif
11

12
void hal_delay(int ms);
13

14
#ifdef __cplusplus
15
}
1 collapsed line
16
#endif

1
extern "C" void SysTick_Handler(void) {
2
    HAL_IncTick();
3
}

1
// malloc 方式（C 风格）
2
int *p1 = (int *)malloc(sizeof(int) * 10);  // 需要强转、手动算大小
3
free(p1);
4

5
// new 方式（C++ 风格）
6
int *p2 = new int[10];   // 自动算大小、类型安全
7
delete[] p2;              // 数组用 delete[]
8

9
// 对于类对象，区别巨大：
10
class Sensor {
11
public:
12
    Sensor() { printf("初始化传感器\n"); }   // 构造函数
13
    ~Sensor() { printf("关闭传感器\n"); }    // 析构函数
14
};
15

5 collapsed lines
16
Sensor *s1 = (Sensor *)malloc(sizeof(Sensor));  // 不会调用构造函数！
17
free(s1);                                        // 不会调用析构函数！
18

19
Sensor *s2 = new Sensor();  // 自动调用构造函数 → 输出"初始化传感器"
20
delete s2;                   // 自动调用析构函数 → 输出"关闭传感器"

1
// C 中
2
const int SIZE = 10;
3
int arr[SIZE];  // C99 之前不允许！SIZE 不是真正的编译期常量
4

5
// C++ 中
6
const int SIZE = 10;
7
int arr[SIZE];  // 完全合法！编译器把 SIZE 替换为 10
8

9
// C++ 中 const 还用于成员函数
10
class Sensor {
11
    int value;
12
public:
13
    int getValue() const { return value; }  // const 成员函数不修改对象
14
    void setValue(int v) { value = v; }
15
};
4 collapsed lines
16

17
const Sensor s;
18
s.getValue();   // OK，const 对象只能调用 const 成员函数
19
// s.setValue(5); // 错误！const 对象不能调用非 const 函数

1
namespace DriverA {
2
    void init() { /* A 公司的初始化 */ }
3
}
4
namespace DriverB {
5
    void init() { /* B 公司的初始化 */ }
6
}
7

8
DriverA::init();  // 调用 A 的 init
9
DriverB::init();  // 调用 B 的 init
10

11
// using 声明（不推荐在头文件中用）
12
using namespace DriverA;
13
init();  // 直接调用 A 的

1
// C++: 原生支持
2
bool flag = true;
3
if (flag) { /* ... */ }
4

5
// C99: 宏定义
6
#include <stdbool.h>  // 定义了 bool=_Bool, true=1, false=0
7
bool flag = true;

1
inline int max(int a, int b) {
2
    return a > b ? a : b;
3
}
4

5
int result = max(x, y);
6
// 编译器可能展开为: int result = x > y ? x : y;
7
// 省去了函数调用的开销

1
void uart_init(int baud = 115200, int databits = 8, int stopbits = 1) {
2
    // 初始化串口
3
}
4

5
uart_init();           // 使用全部默认值: 115200, 8, 1
6
uart_init(9600);       // baud=9600, 其余默认
7
uart_init(9600, 7);    // baud=9600, databits=7, stopbits 默认 1

1
// 自己写一个 GPIO 锁（演示 RAII 思想）
2
class GPIOLock {
3
    int pin;
4
public:
5
    GPIOLock(int p) : pin(p) {
6
        gpio_lock(pin);     // 构造时获取资源（锁住 GPIO）
7
    }
8
    ~GPIOLock() {
9
        gpio_unlock(pin);   // 析构时释放资源（解锁 GPIO）
10
    }
11
};
12

13
void some_function() {
14
    GPIOLock lock(5);       // 构造 → 锁住 GPIO5
15
    // 做一些操作...
10 collapsed lines
16
    // 如果中间抛异常或提前 return，析构函数仍会被调用 → 自动解锁
17
}  // 函数结束，lock 析构 → 自动解锁 GPIO5
18

19
// 对比 C 语言的写法（容易忘记释放）:
20
void some_function_c() {
21
    gpio_lock(5);
22
    // 做一些操作...
23
    if (error) return;     // 忘记解锁！资源泄漏！
24
    gpio_unlock(5);
25
}

1
// 嵌入式RAII经典: 中断锁/GPIO锁
2
class InterruptLock {
3
    uint32_t primask_;
4
public:
5
    InterruptLock() { primask_ = __get_PRIMASK(); __disable_irq(); }  // 构造时关中断
6
    ~InterruptLock() { __set_PRIMASK(primask_); }                     // 析构自动恢复
7
};
8

9
// 使用: 作用域结束自动恢复中断
10
{
11
    InterruptLock lock;       // 关中断
12
    shared_data = new_value;  // 安全操作
13
}                             // 自动恢复中断—即使异常也不会忘记!

1
auto x = 10;        // int
2
auto y = 3.14;      // double
3
auto p = new int;   // int*
4
auto &ref = x;      // int&（引用）
5

6
// 在迭代器中特别有用
7
std::vector<int> v = {1, 2, 3};
8
for (auto it = v.begin(); it != v.end(); ++it) {
9
    // auto 代替了 std::vector<int>::iterator
10
}
11

12
// 范围 for 循环
13
for (auto val : v) {
14
    printf("%d\n", val);
15
}

1
// C 中 NULL 通常定义为: #define NULL ((void*)0) 或 #define NULL 0
2
// C++ 中 NULL 是 0（整数），可能导致重载歧义：
3

4
void func(int n) { printf("int版本\n"); }
5
void func(int *p) { printf("指针版本\n"); }
6

7
func(NULL);     // 调用 int 版本！因为 NULL 就是 0
8
func(nullptr);  // 调用指针版本！nullptr 是真正的空指针类型

1
// 传统 enum（问题：RED 和 ERROR_RED 冲突）
2
enum Color { RED, GREEN, BLUE };
3
enum TrafficLight { RED, YELLOW, GREEN };  // 错误！RED 重复
4

5
// enum class（解决冲突）
6
enum class Color { RED, GREEN, BLUE };
7
enum class Light { RED, YELLOW, GREEN };  // 不冲突
8

9
Color c = Color::RED;   // 必须加作用域
10
Light l = Light::RED;
11

12
// 不能隐式转 int（更安全）
13
// int x = Color::RED;  // 错误！
14
int x = static_cast<int>(Color::RED);  // 必须显式转换
15

7 collapsed lines
16
// 可以指定底层类型（嵌入式中控制大小）
17
enum class GPIO_Mode : uint8_t {
18
    INPUT  = 0,
19
    OUTPUT = 1,
20
    AF     = 2,
21
    ANALOG = 3
22
};  // 只占 1 字节

1
// 类 = 设计图纸
2
class LED {
3
private:
4
    int pin;        // 数据：引脚号
5
    bool state;     // 数据：当前状态
6

7
public:
8
    LED(int p) : pin(p), state(false) {}  // 构造函数
9
    void on()  { state = true;  gpio_set(pin, 1); }   // 操作：开灯
10
    void off() { state = false; gpio_set(pin, 0); }   // 操作：关灯
11
    bool isOn() const { return state; }                // 查询状态
12
};
13

14
// 对象 = 根据设计图造出来的实物
15
LED led1(5);    // 5号引脚的 LED 实例
3 collapsed lines
16
LED led2(6);    // 6号引脚的 LED 实例
17
led1.on();      // 操作对象
18
led2.off();

1
class UART {
2
    int fd;
3
public:
4
    // 构造函数：打开串口
5
    UART(const char *dev, int baud) {
6
        fd = open_uart(dev, baud);
7
        printf("串口已打开, fd=%d\n", fd);
8
    }
9

10
    // 析构函数：关闭串口（自动调用，不会忘记！）
11
    ~UART() {
12
        close(fd);
13
        printf("串口已关闭\n");
14
    }
15

7 collapsed lines
16
    void send(const char *data) { write(fd, data, strlen(data)); }
17
};
18

19
void test() {
20
    UART uart("/dev/ttyS0", 115200);  // 构造 → 打开串口
21
    uart.send("Hello");
22
}  // 函数结束 → uart 析构 → 自动关闭串口

1
class Timer {
2
    const int period;    // const 成员必须用初始化列表
3
    int &ref;           // 引用成员必须用初始化列表
4
    int count;
5

6
public:
7
    // 初始化列表语法：冒号后面 成员(值)
8
    Timer(int p, int &r) : period(p), ref(r), count(0) {
9
        // 函数体中做额外操作
10
    }
11

12
    // 如果用赋值（对于简单类型差别不大，对于类对象开销大）：
13
    // Timer(int p) { period = p; }  // 错误！const 不能赋值
14
};

1
class Buffer {
2
    int *data;
3
    int size;
4
public:
5
    Buffer(int n) : size(n) { data = new int[n]; }
6
    ~Buffer() { delete[] data; }
7

8
    // 拷贝构造函数（深拷贝）
9
    Buffer(const Buffer &other) : size(other.size) {
10
        data = new int[size];                   // 分配新内存
11
        memcpy(data, other.data, size * sizeof(int));  // 复制内容
12
    }
13

14
    // 赋值运算符（深拷贝）
15
    Buffer &operator=(const Buffer &other) {
13 collapsed lines
16
        if (this == &other) return *this;  // 防止自赋值
17
        delete[] data;                     // 释放旧内存
18
        size = other.size;
19
        data = new int[size];              // 分配新内存
20
        memcpy(data, other.data, size * sizeof(int));
21
        return *this;
22
    }
23
};
24

25
Buffer a(100);         // 构造
26
Buffer b = a;          // 拷贝构造（创建新对象）
27
Buffer c(50);
28
c = a;                 // 赋值运算符（已有对象赋值）

1
class Counter {
2
    int count;
3
public:
4
    Counter(int count) {
5
        this->count = count;  // 区分参数和成员（参数名和成员名相同时）
6
    }
7

8
    Counter &increment() {
9
        count++;
10
        return *this;  // 返回自身引用 → 链式调用
11
    }
12
};
13

14
Counter c(0);
15
c.increment().increment().increment();  // 链式调用，count = 3

1
class Sensor {
2
private:
3
    int raw_value;          // 只有内部能直接访问
4

5
protected:
6
    void calibrate() {}     // 子类可以调用
7

8
public:
9
    int getValue() { return raw_value; }   // 对外接口
10
    void update() { raw_value = read_adc(); }
11
};
12

13
// 外部代码：
14
Sensor s;
15
s.getValue();     // OK，public
2 collapsed lines
16
// s.raw_value;   // 错误！private
17
// s.calibrate(); // 错误！protected

1
class Device {
2
    static int device_count;  // 静态成员变量：所有对象共享
3
    int id;
4

5
public:
6
    Device() {
7
        id = ++device_count;   // 每创建一个对象，计数+1
8
    }
9

10
    static int getCount() {    // 静态成员函数：不需要对象就能调用
11
        return device_count;
12
        // 注意：不能用 this, 不能访问非静态成员
13
    }
14
};
15
int Device::device_count = 0;  // 静态成员必须在类外初始化
3 collapsed lines
16

17
Device d1, d2, d3;
18
printf("总设备数: %d\n", Device::getCount());  // 输出 3

1
class Temperature {
2
    float celsius;
3
public:
4
    Temperature(float c) : celsius(c) {}
5

6
    // 声明友元函数：允许它访问 private 的 celsius
7
    friend void printTemp(const Temperature &t);
8

9
    // 声明友元类
10
    friend class Logger;
11
};
12

13
void printTemp(const Temperature &t) {
14
    printf("温度: %.1f°C\n", t.celsius);  // 可以直接访问 private
15
}

1
class Vector2D {
2
public:
3
    float x, y;
4
    Vector2D(float x, float y) : x(x), y(y) {}
5

6
    // 重载 +
7
    Vector2D operator+(const Vector2D &rhs) const {
8
        return Vector2D(x + rhs.x, y + rhs.y);
9
    }
10

11
    // 重载 ==
12
    bool operator==(const Vector2D &rhs) const {
13
        return x == rhs.x && y == rhs.y;
14
    }
15
};
3 collapsed lines
16

17
Vector2D a(1, 2), b(3, 4);
18
Vector2D c = a + b;  // c = (4, 6)，和基本类型一样自然

1
class Voltage {
2
    int mv;
3
public:
4
    explicit Voltage(int millivolts) : mv(millivolts) {}
5
    int get() const { return mv; }
6
};
7

8
Voltage v1(3300);     // OK，显式构造
9
// Voltage v2 = 3300; // 错误！explicit 禁止隐式转换
10
// func(3300);        // 如果 func 参数是 Voltage，也会被禁止
11

12
// 如果没有 explicit，下面的危险代码会编译通过：
13
// void setVoltage(Voltage v) { ... }
14
// setVoltage(42);  // 42 被隐式转换为 Voltage(42)，可能不是你想要的

1
class ADC {
2
    int last_value;
3
public:
4
    int read() {
5
        last_value = read_hw_adc();  // 会修改成员
6
        return last_value;
7
    }
8

9
    int getLastValue() const {  // 不修改任何成员
10
        // last_value = 0;  // 错误！const 函数不能修改成员
11
        return last_value;
12
    }
13
};
14

15
const ADC adc;         // const 对象
2 collapsed lines
16
adc.getLastValue();    // OK
17
// adc.read();         // 错误！const 对象不能调用非 const 函数

1
class Sensor {
2
    mutable int read_count;  // 允许在 const 函数中修改
3
    int value;
4
public:
5
    int getValue() const {
6
        read_count++;   // OK!mutable 允许
7
        return value;
8
    }
9
};

1
// 基类(父类)：通用外设
2
class Peripheral {
3
protected:
4
    uint32_t base_addr;  // 寄存器基地址
5
    bool enabled;
6

7
public:
8
    Peripheral(uint32_t addr) : base_addr(addr), enabled(false) {}
9
    void enable()  { enabled = true;  write_reg(base_addr, 1); }
10
    void disable() { enabled = false; write_reg(base_addr, 0); }
11
};
12

13
// 派生类(子类)：UART 继承了通用外设的所有功能
14
class UART : public Peripheral {
15
    int baud_rate;
9 collapsed lines
16
public:
17
    UART(uint32_t addr, int baud) : Peripheral(addr), baud_rate(baud) {}
18
    void send(char c) { /* UART 特有的发送功能 */ }
19
    void setBaud(int b) { baud_rate = b; /* 设置波特率寄存器 */ }
20
};
21

22
UART uart1(0x40011000, 115200);
23
uart1.enable();   // 继承自 Peripheral 的方法
24
uart1.send('A');  // UART 自己的方法

1
class Base {
2
public:    int a;
3
protected: int b;
4
private:   int c;  // 子类永远不能直接访问
5
};
6

7
class Child : public Base {
8
    void test() {
9
        a = 1;   // OK, 仍是 public
10
        b = 2;   // OK, 仍是 protected
11
        // c = 3; // 错误！父类 private 子类不能访问
12
    }
13
};

1
// 基类
2
class Shape {
3
public:
4
    virtual double area() { return 0; }  // 虚函数 → 多态的关键
5
    virtual ~Shape() {}
6
};
7

8
// 子类1
9
class Circle : public Shape {
10
    double r;
11
public:
12
    Circle(double radius) : r(radius) {}
13
    double area() override { return 3.14159 * r * r; }
14
};
15

17 collapsed lines
16
// 子类2
17
class Rectangle : public Shape {
18
    double w, h;
19
public:
20
    Rectangle(double width, double height) : w(width), h(height) {}
21
    double area() override { return w * h; }
22
};
23

24
// 多态：同一个函数，不同对象表现不同
25
void printArea(Shape *s) {
26
    printf("面积 = %.2f\n", s->area());  // 运行时决定调用哪个 area()
27
}
28

29
Circle c(5.0);
30
Rectangle r(3.0, 4.0);
31
printArea(&c);  // 输出: 面积 = 78.54
32
printArea(&r);  // 输出: 面积 = 12.00

1
类 Shape 的虚函数表:       类 Circle 的虚函数表:
2
┌────────────┐           ┌────────────┐
3
│ &Shape::area │          │ &Circle::area │  ← 重写后指向新函数
4
│ &Shape::~Shape│          │ &Circle::~Circle│
5
└────────────┘           └────────────┘
6

7
对象内存布局:
8
┌──────────────────────┐
9
│ vptr → [vtable 地址]  │  ← 隐藏的虚表指针(通常在对象开头)
10
├──────────────────────┤
11
│ 成员变量              │
12
└──────────────────────┘
13

14
调用 s->area() 时：
15
1. 通过 s 找到对象
3 collapsed lines
16
2. 读取对象的 vptr
17
3. 在 vtable 中找到 area() 的地址
18
4. 跳转执行

1
// 抽象基类：定义接口
2
class Driver {
3
public:
4
    virtual int init() = 0;          // 纯虚函数，= 0 表示没有默认实现
5
    virtual int read(void *buf, int len) = 0;
6
    virtual int write(const void *buf, int len) = 0;
7
    virtual ~Driver() {}
8
};
9

10
// 具体实现：SPI 驱动
11
class SPIDriver : public Driver {
12
public:
13
    int init() override { /* SPI 初始化 */ return 0; }
14
    int read(void *buf, int len) override { /* SPI 读 */ return len; }
15
    int write(const void *buf, int len) override { /* SPI 写 */ return len; }
6 collapsed lines
16
};
17

18
// Driver d;          // 错误！抽象类不能实例化
19
SPIDriver spi;       // OK
20
Driver *drv = &spi;  // OK，基类指针指向子类对象
21
drv->init();         // 多态调用 SPIDriver::init()

1
class Base {
2
public:
3
    virtual void func(int x) {}
4
};
5

6
class Child : public Base {
7
public:
8
    void func(int x) override {}    // OK，正确重写
9
    // void func(float x) override {} // 错误！父类没有 func(float)
10
    //                                  override 帮你发现拼写/参数错误
11
};
12

13
class Final : public Child {
14
public:
15
    void func(int x) final {}   // 这个类的子类不能再重写 func
6 collapsed lines
16
};
17

18
class FinalClass final {  // 整个类不能被继承
19
    // ...
20
};
21
// class X : public FinalClass {};  // 错误！不能继承 final 类

1
class Base {
2
public:
3
    virtual ~Base() { printf("Base 析构\n"); }  // 必须是 virtual！
4
};
5

6
class Derived : public Base {
7
    int *buffer;
8
public:
9
    Derived() { buffer = new int[100]; }
10
    ~Derived() {
11
        delete[] buffer;   // 释放子类独有的资源
12
        printf("Derived 析构\n");
13
    }
14
};
15

4 collapsed lines
16
Base *p = new Derived();
17
delete p;
18
// 输出: Derived 析构 → Base 析构（正确）
19
// 如果 ~Base() 不是 virtual → 只调用 Base 析构 → buffer 泄漏！

1
         Animal
2
        /      \
3
    Cat          Dog
4
        \      /
5
        CatDog ← 有两份 Animal 的成员？
6

7
解决方案：虚继承(virtual inheritance)
8
cpp
9
class Animal {
10
public:
11
    int age;
12
};
13

14
class Cat : virtual public Animal {};   // 虚继承
15
class Dog : virtual public Animal {};   // 虚继承
4 collapsed lines
16
class CatDog : public Cat, public Dog {};
17

18
CatDog cd;
19
cd.age = 3;  // 只有一份 age，没有歧义

1
// 组合（推荐）
2
class Engine { public: void start() {} };
3
class Wheel  { public: void rotate() {} };
4

5
class Car {
6
    Engine engine;     // Car 有一个 Engine
7
    Wheel wheels[4];   // Car 有 4 个 Wheel
8
public:
9
    void drive() {
10
        engine.start();
11
        for (auto &w : wheels) w.rotate();
12
    }
13
};
14

15
// 继承（只在真正的 is-a 关系时用）
1 collapsed line
16
// class Car : public Engine {}  ← 错误！车不是引擎！

1
class NoVirtual { int x; };           // sizeof = 4
2
class HasVirtual { int x; virtual void f(); };  // sizeof = 8 (32位: 4+4)
3

4
// 嵌入式中1000个对象 → 多 4KB 内存开销
5
// 如果内存非常紧张(如 2KB RAM 的 MCU)，避免虚函数

1
class MyClass {
2
    // 如果你不写，编译器自动生成以下 6 个（C++11）:
3
    MyClass();                             // 默认构造
4
    ~MyClass();                            // 析构
5
    MyClass(const MyClass &);              // 拷贝构造
6
    MyClass &operator=(const MyClass &);   // 拷贝赋值
7
    MyClass(MyClass &&);                   // 移动构造 (C++11)
8
    MyClass &operator=(MyClass &&);        // 移动赋值 (C++11)
9
};

1
// C++11: = delete
2
class Singleton {
3
public:
4
    Singleton(const Singleton &) = delete;            // 禁止拷贝
5
    Singleton &operator=(const Singleton &) = delete; // 禁止赋值
6

7
    static Singleton &getInstance() {
8
        static Singleton instance;
9
        return instance;
10
    }
11
private:
12
    Singleton() {}
13
};

1
class Buffer {
2
    int *data;
3
    int size;
4
public:
5
    // 移动构造函数
6
    Buffer(Buffer &&other) noexcept : data(other.data), size(other.size) {
7
        other.data = nullptr;  // "偷走"资源后，把原对象置空
8
        other.size = 0;
9
    }
10
};
11

12
Buffer createBuffer() {
13
    Buffer b(1000);
14
    return b;  // 返回时触发移动(而不是拷贝1000个int)
15
}

1
// 不用模板 → 每种类型写一遍
2
int max_int(int a, int b) { return a > b ? a : b; }
3
float max_float(float a, float b) { return a > b ? a : b; }
4
// 太重复了...
5

6
// 用模板 → 写一次，适用所有类型
7
template <typename T>
8
T my_max(T a, T b) {
9
    return a > b ? a : b;
10
}
11

12
my_max(3, 5);       // 编译器生成 int 版本
13
my_max(3.14, 2.71); // 编译器生成 double 版本

1
// 环形缓冲区模板（嵌入式超常用）
2
template <typename T, int SIZE>
3
class RingBuffer {
4
    T data[SIZE];
5
    int head = 0, tail = 0, count = 0;
6

7
public:
8
    bool push(const T &item) {
9
        if (count >= SIZE) return false;  // 满了
10
        data[tail] = item;
11
        tail = (tail + 1) % SIZE;
12
        count++;
13
        return true;
14
    }
15

19 collapsed lines
16
    bool pop(T &item) {
17
        if (count == 0) return false;     // 空的
18
        item = data[head];
19
        head = (head + 1) % SIZE;
20
        count--;
21
        return true;
22
    }
23

24
    bool isEmpty() const { return count == 0; }
25
    bool isFull() const { return count >= SIZE; }
26
};
27

28
// 使用：
29
RingBuffer<uint8_t, 256> uart_rx_buf;   // 串口接收缓冲区, uint8_t 类型, 256 大小
30
RingBuffer<int, 32> sensor_buf;          // 传感器数据缓冲区
31

32
uart_rx_buf.push(0x48);
33
uint8_t ch;
34
uart_rx_buf.pop(ch);

1
// 通用版本
2
template <typename T>
3
T abs_value(T x) {
4
    return x >= 0 ? x : -x;
5
}
6

7
// 针对 bool 类型的特化（全特化）
8
template <>
9
bool abs_value<bool>(bool x) {
10
    return x;  // bool 没有负值
11
}
12

13
// 偏特化（部分模板参数特化）— 只能用于类模板
14
template <typename T>
15
class Storage {
12 collapsed lines
16
    T data;
17
public:
18
    void save(T d) { data = d; }
19
};
20

21
// 对指针类型偏特化
22
template <typename T>
23
class Storage<T*> {
24
    T *data;
25
public:
26
    void save(T *d) { data = d; /* 可能需要深拷贝 */ }
27
};

1
template <typename T>   // typename 风格
2
T add(T a, T b) { return a + b; }
3

4
template <class T>      // class 风格，功能完全相同
5
T sub(T a, T b) { return a - b; }
6

7
// typename 的另一个用途：指明嵌套依赖类型
8
template <typename T>
9
void func() {
10
    typename T::iterator it;  // 告诉编译器 T::iterator 是类型，不是变量
11
}

1
// 递归终止条件
2
void print() { printf("\n"); }
3

4
// 可变参数版 print
5
template <typename T, typename... Args>
6
void print(T first, Args... rest) {
7
    printf("%d ", first);   // 处理第一个
8
    print(rest...);         // 递归处理剩余
9
}
10

11
print(1, 2, 3, 4, 5);  // 输出: 1 2 3 4 5

1
// 编译期计算波特率分频值
2
constexpr uint32_t calc_brr(uint32_t pclk, uint32_t baud) {
3
    return pclk / baud;
4
}
5

6
// 在编译时就算好了，不占运行时间
7
constexpr uint32_t BRR_115200 = calc_brr(72000000, 115200);  // = 625
8

9
// 编译期查找表
10
constexpr int factorial(int n) {
11
    return n <= 1 ? 1 : n * factorial(n - 1);
12
}
13
constexpr int f5 = factorial(5);  // 编译时 = 120
14

15
// 编译期 GPIO 配置
2 collapsed lines
16
constexpr uint32_t GPIO_PIN(int n) { return 1U << n; }
17
constexpr uint32_t LED_PIN = GPIO_PIN(13);  // = 0x2000