一、引言

"嵌入式中能用 C++ 吗？"——这是嵌入式领域争论最多的问题之一。

结论先行：能用，但要取子集。

C++ 的一些特性（封装、继承、多态、模板）可以显著提高代码的抽象能力和复用性；但另一些特性（异常、RTTI、iostream、STL 容器）带来的 ROM/RAM 开销和运行时不确定性在 MCU 上不可接受。

本文从嵌入式开发者的角度出发，分析 C++ 各特性在 STM32F103（20KB SRAM、64KB Flash）上的实际开销，并给出安全可用的 C++ 子集。

二、C 与 C++ 的本质差异

2.1 最根本的区别

2.2 嵌入式 C++ 能用的子集

推荐使用的 C++ 特性： ✅ 类 + 封装（private/protected/public）—— 零开销 ✅ 构造函数/析构函数—— 零开销（调用等价于普通函数） ✅ 命名空间（namespace）—— 零开销 ✅ 引用（reference）—— 零开销（本质上是指针语法糖） ✅ 函数重载（overload）—— 零开销（编译期解决） ✅ 模板（template）—— 编译期展开，零运行时开销 ✅ constexpr —— 编译期计算，零运行时开销 ​ 谨慎使用的特性： ⚠️ 继承（无虚函数时）—— 零开销，但设计复杂度增加 ⚠️ 运算符重载—— 确保生成代码与 C 版本一致 ​ 避免使用的特性： ❌ 异常（exception）—— 需要栈展开表（.eh_frame），ROM 剧增 ~10KB+（与 RTTI 是两个独立特性，用 -fno-exceptions / -fno-rtti 分别禁用） ❌ RTTI（typeid/dynamic_cast）—— 额外 ROM，运行时不确定 ❌ iostream（cin/cout）—— 极大，替代用 printf ❌ STL 容器（vector/map/string）—— 动态内存分配，在 MCU 上不可预测 ⚠️ 虚函数（virtual）—— vtable 开销小，谨慎使用（见下文 3.3 量化分析）

三、C++ 特性的开销分析

3.1 封装（类）——零开销

// C 风格 typedef struct { int pin; int port; } GPIO_Pin; ​ void GPIO_SetHigh(GPIO_Pin *p) { /* ... */ } void GPIO_SetLow(GPIO_Pin *p) { /* ... */ } ​ // C++ 风格（类的封装） class GPIO { private: int m_pin; int m_port; public: GPIO(int pin, int port) : m_pin(pin), m_port(port) {} void SetHigh() { /* ... */ } void SetLow() { /* ... */ } }; ​ // GCC 编译后的汇编完全一致！零开销抽象

3.2 重载和内联

// 函数重载（编译期决定，零运行时开销） void vWriteValue(uint8_t val) { /* 8位寄存器 */ } void vWriteValue(uint16_t val) { /* 16位寄存器 */ } void vWriteValue(uint32_t val) { /* 32位寄存器 */ } ​ // inline 建议（消除函数调用开销） // 嵌入式对频繁调用的小函数非常有益 static inline uint32_t ulGPIO_ReadODR(GPIO_TypeDef *GPIOx) { return GPIOx->ODR; }

3.3 虚函数——嵌入式中最需要警惕的特性

class UART { public: virtual void Send(uint8_t data) = 0; // 纯虚函数 virtual void Init(uint32_t baud) = 0; }; ​ class UART1 : public UART { public: void Send(uint8_t data) override { /* USART1 操作 */ } void Init(uint32_t baud) override { /* USART1 初始化 */ } }; ​ class UART2 : public UART { public: void Send(uint8_t data) override { /* USART2 操作 */ } void Init(uint32_t baud) override { /* USART2 初始化 */ } };

虚函数的开销：

对象 UART1（多了一个隐式的 vptr 指针）： ┌──────────────────┐ │ vptr (4 字节) │──→ vtable（在 Flash 中） │ 成员变量 │ ┌──────────────┐ └──────────────────┘ │ Send() → addr │ │ Init() → addr │ vptr 指向的是 vtable， └──────────────┘ 每个类一个 vtable 每个对象多 4 字节（vptr） ​ 调用 pUART->Send(data) 的汇编： LDR R0, [pUART] ; 读取 vptr LDR R0, [R0, #0] ; 从 vtable 取 Send 地址 BLX R0 ; 间接调用 → 比普通函数多一次间接寻址，但开销很小（约 2 cycles）

结论：虚函数的性能开销可以忽略（2 cycles），但设计上会引入动态特性（运行时才确定调哪个函数），这在嵌入式领域有时是不必要的抽象。只有在确实需要"同一个接口多种实现"时才用虚函数。

3.4 模板——编译期多态，零开销

// 模板：编译期生成具体代码，没有运行时开销 template<typename T> T tMax(T a, T b) { return (a > b) ? a : b; } ​ // 使用 int m = tMax(3, 5); // 生成 int Max(int, int) float f = tMax(3.14f, 2.71f); // 生成 float Max(float, float) ​ // 模板在嵌入式中的经典应用：寄存器操作抽象 template<uint32_t addr> class Register { public: static void Write(uint32_t val) { *(volatile uint32_t *)addr = val; } static uint32_t Read() { return *(volatile uint32_t *)addr; } }; ​ // 使用：零开销，完全编译期解析 using USART1_SR = Register<0x40013800>; using USART1_DR = Register<0x40013804>; uint32_t sr = USART1_SR::Read();

四、RAII——嵌入式资源管理利器

RAII（Resource Acquisition Is Initialization）是 C++ 中最有价值的特性之一。

4.1 传统 C 的资源管理问题

// C 风格：忘记关闭或异常分支漏关 void vProcessData(void) { __disable_irq(); // 关中断 // ... 处理 ... if (error) { return; // ❌ 忘了 __enable_irq()! } __enable_irq(); // 开中断 } ​ // 或者多个出口时： void vFunction(void) { __disable_irq(); if (cond1) { __enable_irq(); // 每个出口都要写 return; } if (cond2) { __enable_irq(); return; } __enable_irq(); }

4.2 C++ RAII 解决方案

// RAII 封装临界区 class CriticalSection { public: CriticalSection() { taskENTER_CRITICAL(); } ~CriticalSection() { taskEXIT_CRITICAL(); } // 禁止拷贝 CriticalSection(const CriticalSection&) = delete; CriticalSection& operator=(const CriticalSection&) = delete; }; ​ // 使用：析构函数自动释放，无论从哪条路径退出 void vProcessData(void) { CriticalSection cs; // 构造时关中断 // ... 处理 ... if (error) { return; // 析构自动 taskEXIT_CRITICAL()! } // 正常处理... } // 离开作用域，自动开中断 ​ // 更实用的例子：SPI 片选管理器 class SPISelectGuard { private: GPIO_TypeDef *m_port; uint16_t m_pin; public: SPISelectGuard(GPIO_TypeDef *port, uint16_t pin) : m_port(port), m_pin(pin) { GPIO_ResetBits(m_port, m_pin); // CS 拉低 } ~SPISelectGuard() { GPIO_SetBits(m_port, m_pin); // CS 拉高 } }; ​ void vReadSensor(uint8_t addr) { SPISelectGuard cs(GPIOA, GPIO_Pin_4); // CS 自动拉低 ucSPI_Transfer(addr); // 传输 uint8_t val = ucSPI_Transfer(0x00); // CS 在 } 处自动拉高——无论前面是否 return ProcessValue(val); }

五、嵌入式 C++ 设计模式实战

5.1 硬件抽象：用模板代替虚函数

// 方案 A：虚函数（运行期多态，有 vtable 开销） class SPIDevice { public: virtual void Write(uint8_t data) = 0; }; // 方案 B：模板（编译期多态，零开销） template<typename T_HAL> class SPIDevice { public: void Write(uint8_t data) { T_HAL::Send(data); // 编译期绑定 } }; // 具体实现 struct SPI1_HAL { static void Send(uint8_t data) { /* SPI1 发送 */ } }; struct SPI2_HAL { static void Send(uint8_t data) { /* SPI2 发送 */ } }; // 使用：零开销，编译期就确定调用哪个 SPI SPIDevice<SPI1_HAL> spi1; SPIDevice<SPI2_HAL> spi2;

5.2 有限状态机（FSM）——OOP 封装

class StateMachine { public: enum State { IDLE, ACTIVE, ERROR }; void HandleEvent(Event evt) { switch (m_state) { case IDLE: if (evt == START) { OnEnterActive(); m_state = ACTIVE; } break; case ACTIVE: if (evt == TIMEOUT) { OnTimeout(); m_state = ERROR; } break; case ERROR: if (evt == RESET) { m_state = IDLE; } break; } } State GetState() const { return m_state; } private: State m_state = IDLE; void OnEnterActive() { /* 进入 ACTIVE 时的操作 */ } void OnTimeout() { /* 超时处理 */ } };

5.3 Singleton 模式——用于硬件管理器

class SystemClock { public: static SystemClock& GetInstance() { static SystemClock instance; return instance; } void InitHSE() { /* ... */ } void InitPLL() { /* ... */ } uint32_t GetFreq() const { return m_freq; } private: SystemClock() {} // 私有构造 SystemClock(const SystemClock&) = delete; // 禁止拷贝 uint32_t m_freq = 72000000; }; // 使用 SystemClock::GetInstance().InitHSE(); uint32_t freq = SystemClock::GetInstance().GetFreq();

六、嵌入式 C++ 编译器设置（GCC）

6.1 推荐编译选项

# ARM GCC 嵌入式 C++ 推荐选项 CXXFLAGS = \ -mcpu=cortex-m3 \ -mthumb \ -Os \ -fno-exceptions \ # ❌ 禁用异常 -fno-rtti \ # ❌ 禁用 RTTI -fno-threadsafe-statics \ # 单核 MCU 不需要静态变量线程安全 -ffunction-sections \ # 未使用函数不链接 -fdata-sections \ -Wall -Wextra # 链接时垃圾回收 LDFLAGS = -Wl,--gc-sections # 对比：启用异常 vs 禁用异常的 ROM 大小 # 启用异常（-fexceptions）：Flash 占用 ~12KB # 禁用异常（-fno-exceptions）：Flash 占用 0（额外开销）

6.2 使用 C++ 但确保与 C 链接

/* main.h — 提供 C 兼容接口 */ #ifdef __cplusplus extern "C" { #endif void SystemClock_Config(void); void vMainTask(void *pv); #ifdef __cplusplus } #endif /* main.cpp */ #include "main.h" // C++ 实现的函数，但导出为 C 符号（供启动文件调用） extern "C" void SystemClock_Config(void) { // 内部可以用 C++ 特性 auto& clk = SystemClock::GetInstance(); clk.InitHSE(); clk.InitPLL(); }

七、工程建议：什么时候用 C++？

嵌入式中使用 C++ 的清单检查

□ 禁用异常（-fno-exceptions） □ 禁用 RTTI（-fno-rtti） □ 不用 STL 容器（vector/map/string） □ 不用 iostream（用 printf/自己写输出） □ 不用 new/delete（用静态分配） □ 虚函数只用在确实需要运行时多态时 □ 模板只用来做编译期多态 ≠ 运行时多态 □ 全局对象构造函数不放复杂初始化 □ 所有中断服务函数用 extern "C"

八、总结

C++ 在嵌入式中的定位： 使用 C++ 合理的特性（85%的场景）： 封装、命名空间、重载、引用、constexpr、RAII、模板 避免使用的特性（15%的场景）： 异常、RTTI、iostream、STL 容器、虚函数（过度使用） 核心原则： "零开销抽象"（Zero-overhead abstraction） 你不需要为没用到的特性付出任何成本

C++ 在嵌入式领域不是"能不能用"的问题，而是"怎么用"的问题。取合适的子集，可以兼得 C 的执行效率和 C++ 的抽象能力。

下一篇：[单片机核心外设设计精要 —— 定时器、PWM、DMA、ADC、看门狗原理与实战]