简说 Arduino 库与 C++

简说 Arduino 核心代码（包括库、用户 Sketch）中用到的 C++ 特性，并说明它们是如何在微控制器环境中被使用的。

🌟 Arduino 使用到的主要 C++ 特性

🔍 Arduino 代码的 C++ 特性示例

class Print {
public:
  virtual size_t write(uint8_t) = 0;  // 多态接口
  size_t print(const char *str) {     // 内联可能会用
    while (*str) {
      write(*str++);
    }
    return 0;
  }
};

class HardwareSerial : public Stream {
public:
  virtual size_t write(uint8_t c) override {
    // 硬件串口写出
  }
};

这里用到的特性：
✅ 类
✅ 继承
✅ 虚函数（多态）
✅ 覆盖
✅ 内联（可能被编译器内联）

🚀 Arduino 为什么避开某些高级 C++ 特性？

🌱 总结：Arduino C++ 用法风格

✅ 用：

• 基本面向对象：类、继承、多态（虚函数）、运算符重载
• 简单模板（少量）
• 静态成员、引用、默认参数

❌ 避免：

• 异常处理
• RTTI
• 复杂模板编程
• 深层次泛型

🚀 Arduino 库对 C++ STL 的简化封装 / 重新实现

Arduino 为了适配微控制器资源受限的特点，并没有完整使用 C++ STL（标准模板库），但它重新实现了 STL 中一些常用的功能，具体包括：

1️⃣ 字符串处理

2️⃣ 流（Stream）输入输出

3️⃣ 缓冲区 / 队列

4️⃣ 数值转换

5️⃣ 其他

✅ 没有完整重新实现 的 STL 部分包括：

• 容器类：如 std::vector, std::map, std::set 等。Arduino 核心库没有内置实现。开发者若需要必须自行引入第三方轻量 STL 库或写数组管理代码。
• 算法库：没有重新实现 std::sort, std::find, std::accumulate 等。
• 智能指针 / RAII：没有 std::unique_ptr, std::shared_ptr 等。

🌟 总结

🌟 Arduino 简化实现 vs C++ STL：内存占用 & 性能对比

🚀 1️⃣ 字符串：WString vs std::string

💡 示例差异

🚀 2️⃣ 缓冲队列：RingBuffer vs std::queue

🚀 3️⃣ 数字转换：itoa/dtostrf vs std::to_string

🔍 整体内存开销对比（实际经验值）

💡 实际例子对比：WString vs std::string

假如写一个简单串口回显程序，使用 WString 和 std::string：

• WString: 编译后程序 6 KB，RAM 占用 < 1 KB。
• std::string (ArduinoSTL): 编译后程序体积 12 KB+，RAM 占用 1.5~2 KB（取决于字符串操作复杂度）。

🚀 为什么 Arduino 不直接用 STL？

✅ STL 功能强大，但：

• 代码体积大，不适合 flash/RAM 小于 32K 的芯片。
• 动态分配多，容易内存碎片。
• 模板膨胀导致编译产物变大。
• 异常、RTTI 等功能微控制器通常禁用。

深入对比 Arduino 上纯 C 风格 和 C++ 面向对象写法在代码体积、性能上的区别。

🌟 对比维度

🚀 实际例子对比：LED 控制

1️⃣ 纯 C 风格代码（最小体积）：

#define LED_PIN 13

void led_on() {
  digitalWrite(LED_PIN, HIGH);
}

void led_off() {
  digitalWrite(LED_PIN, LOW);
}

void setup() {
  pinMode(LED_PIN, OUTPUT);
}

void loop() {
  led_on();
  delay(500);
  led_off();
  delay(500);
}

✅ 编译体积（AVR UNO 示例）

• Flash: ~1,004 bytes
• RAM: ~9 bytes

性能：

• 函数调用直接内联（编译器可能优化）
• 无虚函数或调度开销

2️⃣ C++ 面向对象写法：

class Led {
private:
  uint8_t pin;
public:
  Led(uint8_t p) : pin(p) {}
  void on() { digitalWrite(pin, HIGH); }
  void off() { digitalWrite(pin, LOW); }
};

Led led(13);

void setup() {
  pinMode(13, OUTPUT);
}

void loop() {
  led.on();
  delay(500);
  led.off();
  delay(500);
}

✅ 编译体积（AVR UNO 示例）

• Flash: ~1,070 bytes
• RAM: ~11 bytes

性能：

• 几乎与 C 相同，无虚函数，无额外调度开销
• 构造函数初始化时可能多一点代码

3️⃣ C++ 多态写法（虚函数引入调度）：

class LedBase {
public:
  virtual void on() = 0;
  virtual void off() = 0;
};

class Led : public LedBase {
private:
  uint8_t pin;
public:
  Led(uint8_t p) : pin(p) {}
  void on() override { digitalWrite(pin, HIGH); }
  void off() override { digitalWrite(pin, LOW); }
};

Led led(13);
LedBase* pled = &led;

void setup() {
  pinMode(13, OUTPUT);
}

void loop() {
  pled->on();
  delay(500);
  pled->off();
  delay(500);
}

✅ 编译体积（AVR UNO 示例）

• Flash: ~1,170 bytes
• RAM: ~13 bytes

性能：

• 每次 on / off 调用都会通过 vtable 间接调用，指令稍多
• 间接调度会比直接调用多 2-3 个周期（对于 MCU 来说可忽略，但在高频调用场景会累积）

📊 对比数据表

💡 结论

✅ 体积

• 简单 C 风格最小。
• 面向对象类封装会略大（构造/析构代码 + 封装元数据）。
• 多态引入虚表后体积明显增大（每个虚函数占 vtable slot 和调度代码）。

✅ 性能

• C 风格、普通类：直接调用，没有额外指令。
• 多态：每次调用需通过虚表间接跳转，稍慢（对于 Arduino 的 16MHz 主频，可能多几个周期）。

✅ 扩展性 / 可维护性

• C 风格：代码紧凑但扩展性弱，难维护。
• C++ 类：易于扩展、维护、复用，体积和性能损耗小。
• 多态：适合需要接口抽象的情况，但要注意体积和调度开销。

🌱 建议

在 Arduino 上：
💡 能用简单类封装就用类，不必为了体积完全排斥 C++ 特性。
💡 虚函数/多态慎用，除非真的需要可扩展的抽象接口。
💡 避免动态内存分配和过多模板，以减少体积和碎片。

🌟 C++ 静态函数 与 静态成员的区别与用途

🔹 示例代码

class Led {
private:
  uint8_t pin;
  static uint8_t ledCount;   // 静态数据成员
public:
  Led(uint8_t p) : pin(p) {
    ledCount++;
  }

  void on() {
    digitalWrite(pin, HIGH);
  }

  void off() {
    digitalWrite(pin, LOW);
  }

  static void showCount() {  // 静态成员函数
    Serial.println(ledCount);
  }
};

// 静态成员初始化（类外定义）
uint8_t Led::ledCount = 0;

void setup() {
  Serial.begin(9600);
  pinMode(13, OUTPUT);
  Led led1(13);
  led1.on();
  Led::showCount();  // 静态函数调用，不需要对象
}

void loop() {}

🔑 重点理解

🌟 静态数据成员

• 只有一份内存，不管你创建多少对象。
• 适合记录类的共享数据，例如硬件状态、设备数量。

🌟 静态成员函数

• 没有 this 指针，不能访问对象的普通成员。
• 可以访问静态数据成员。
• 适合写一些工具函数、工厂函数或硬件操作接口。

⚡ 在 Arduino / MCU 中常用场景

⚠ 注意事项

• 静态成员初始化必须在类外完成（除非是 const 整数且 C++17 前不支持内联初始化）。
• 静态函数不能直接访问普通成员（因为没有 this）。

💡 总结口诀

👉 静态函数是“类方法”，静态变量是“类数据”。
👉 静态函数像全局函数，但封装在类里。
👉 静态变量所有对象共享，用于保存类级别状态。

C++ 静态成员初始化 的规则，特别是嵌入式（如 Arduino）场景下的实用重点。

🌟 静态数据成员初始化为什么要在类外完成？

原因：

1️⃣ 静态数据成员 属于类，而不是对象，它只存在一份在全局或静态存储区（data / bss 段）。
2️⃣ C++ 标准规定：类定义只声明静态数据成员，它的实际存储空间（内存分配）在类外初始化时分配。

例如：

class Led {
public:
  static int count;  // 声明：没有分配空间
};

// 类外初始化，分配空间
int Led::count = 0;

如果你只写声明（类内 static int count;），编译器知道有这个符号，但链接阶段找不到它的定义（即空间位置），会报错：

undefined reference to `Led::count'

🌟 类外初始化的写法

class MyClass {
public:
  static int shared_value;
};

// 类外初始化
int MyClass::shared_value = 0;

👉 注意：如果不在类外初始化，静态数据成员在链接时会找不到符号。

🌟 例外：可以类内初始化的情况

✅ C++11/C++14 支持类内初始化：
对于静态 const 整型 或枚举 或 constexpr，可以在类内直接初始化。

class MyClass {
public:
  static const int max_value = 100;  // 类内初始化 OK
  static constexpr int factor = 10;  // 类内初始化 OK
};

这些值编译器可以在编译期确定，不需要额外分配存储。

⚠ 但如果你 取它们的地址（如 &MyClass::max_value），链接阶段仍然需要定义（除非是 constexpr）。

🌟 C++17 后的新变化

C++17 引入了 inline static data member：

class MyClass {
public:
  inline static int counter = 0;  // 类内初始化，不需要类外定义
};

• 不需要类外再写 int MyClass::counter = 0;
• 编译器会生成一份定义
• 很适合嵌入式工具类、模板类写法

但是 Arduino 编译器可能不支持完整 C++17，要看具体平台（如 ESP32 支持好，AVR 平台一般停在 C++11/14）。

🌟 Arduino / MCU 场景提示

💡 例子

class Led {
public:
  static const int defaultBrightness = 128;   // OK
  static int ledCount;                        // 需要类外初始化
};

int Led::ledCount = 0;   // 类外初始化，分配存储空间

🌟 总结口诀

👉 静态成员空间类外分，类内只是个声明单。
👉 const int、constexpr 类内能，普通静态类外分。
👉 若是 inline static（C++17），类内定义真方便。