在 RT-Thread/MCU 上安全使用 C++：从编译器基线到零开销抽象实践

target_compile_options(<target> PRIVATE
    -std=c++17
    -fno-exceptions        # 消除 .eh_frame/.gcc_except_table，节省 ROM 5-15%
    -fno-rtti              # 消除 typeinfo 对象，节省 ROM 1-3%
    -ffunction-sections -fdata-sections  # 配合 --gc-sections 裁剪未使用代码
)
target_link_options(<target> PRIVATE --gc-sections)

# rtconfig.py
CXXFLAGS = CFLAGS + ' -std=c++17 -fno-exceptions -fno-rtti'

LDR  r0, [obj]          ; 取 vtable 指针（1 次内存读）
LDR  r1, [r0, #offset]  ; 取函数指针（1 次内存读）
BLX  r1                 ; 间接跳转（分支预测失效）

typedef struct {
    rt_err_t (*init)  (rt_device_t dev);
    rt_err_t (*open)  (rt_device_t dev, rt_uint16_t oflag);
    rt_size_t (*read) (rt_device_t dev, rt_off_t pos,
                       void *buf, rt_size_t size);
    rt_size_t (*write)(rt_device_t dev, rt_off_t pos,
                       const void *buf, rt_size_t size);
    rt_err_t (*close) (rt_device_t dev);
} struct rt_device_ops;

static const struct rt_device_ops uart_ops = {
    .init  = uart_init,
    .open  = uart_open,
    .read  = uart_read,
    .write = uart_write,
    .close = uart_close,
};

template <typename Derived>
class SensorBase {
public:
    void read() {
        /* 编译期决议，O2 下全部内联，机器码与手写 C 等价 */
        static_cast<Derived*>(this)->read_impl();
    }
};

class TemperatureSensor : public SensorBase<TemperatureSensor> {
public:
    void read_impl() { /* 读 ADC 寄存器 */ }
};

class Utils {
public:
    /* 浮点版本：误差比较 */
    template <typename T,
              std::enable_if_t<std::is_floating_point<T>::value, bool> = true>
    static bool is_equal(T a, T b) noexcept {
        return std::abs(a - b) < static_cast<T>(1e-6);
    }

    /* 整数版本：精确比较 */
    template <typename T,
              std::enable_if_t<std::is_integral<T>::value, bool> = true>
    static bool is_equal(T a, T b) noexcept {
        return a == b;
    }

    /* 类型安全的多参数乘法，common_type 自动提升精度 */
    template <typename Out, typename First, typename... Rest>
    static constexpr Out static_mul(First f, Rest... r) noexcept {
        using C = std::common_type_t<First, Rest...>;
        return static_cast<Out>(static_cast<C>(f) * static_mul<C>(r...));
    }
    template <typename Out, typename A, typename B>
    static constexpr Out static_mul(A a, B b) noexcept {
        using C = std::common_type_t<A, B>;
        return static_cast<Out>(static_cast<C>(a) * static_cast<C>(b));
    }
};

/* 调用：编译期展开为一条乘法链，static_cast 保证类型安全 */
uint32_t pixels = Utils::static_mul<uint32_t>(width, height, channels);

/* CRC32（反转多项式 0xEDB88320）查找表，256 项，放入 .rodata */
constexpr uint32_t crc32_byte(uint32_t i) noexcept {
    for (int b = 0; b < 8; ++b) {
        i = (i & 1U) ? (0xEDB88320U ^ (i >> 1)) : (i >> 1);
    }
    return i;
}
template <size_t... I>
constexpr std::array<uint32_t, 256> make_crc32_table(
        std::index_sequence<I...>) noexcept {
    return {{ crc32_byte(static_cast<uint32_t>(I))... }};
}
constexpr auto kCrc32Table =
    make_crc32_table(std::make_index_sequence<256>{});

/* 运行时查表：仅一条 LDR，无计算 */
uint32_t crc32_update(uint32_t crc, uint8_t byte) noexcept {
    return (crc >> 8) ^ kCrc32Table[(crc ^ byte) & 0xFFU];
}

template <uint32_t Capacity>
class FixedString {
    static_assert(Capacity > 0U, "Capacity must be > 0");
public:
    constexpr FixedString() noexcept : buf_{'\0'}, size_(0U) {}

    /* 字符串字面量构造：编译期长度检查，超长直接报错 */
    template <uint32_t N, typename = std::enable_if_t<(N <= Capacity + 1U)>>
    FixedString(const char (&str)[N]) noexcept : size_(N - 1U) {
        static_assert(N - 1U <= Capacity, "literal exceeds FixedString capacity");
        std::memcpy(buf_, str, N);
    }

    /* 运行时截断构造（显式标签，避免静默截断） */
    FixedString(TruncateToCapacity_t, const char* str) noexcept;

    [[nodiscard]] constexpr const char* c_str()     const noexcept { return buf_; }
    [[nodiscard]] constexpr uint32_t    size()       const noexcept { return size_; }
    static        constexpr uint32_t    capacity()         noexcept { return Capacity; }
    [[nodiscard]] constexpr bool        empty()      const noexcept { return size_ == 0U; }

private:
    char     buf_[Capacity + 1U];
    uint32_t size_;
};

/* 使用 */
FixedString<64> path = "firmware/default.bin";      /* 编译期长度检查 */
FixedString<64> name{TruncateToCapacity, user_buf}; /* 显式截断，安全 */

FixedVector<uint16_t, 256> adc_samples;
adc_samples.push_back(read_adc());

/* std::sort / std::transform 不分配堆，完全兼容 */
std::sort(adc_samples.begin(), adc_samples.end());
auto peak = *std::max_element(adc_samples.begin(), adc_samples.end());

---

## 7. 内存池 + 智能指针：零堆 RAII

当对象生命周期无法绑定到固定栈作用域时，用内存池 + 自定义删除器替代裸 `new/delete`。[newosp](https://github.com/DeguiLiu/newosp) 的 `mem_pool.hpp` 提供了嵌入式友好的固定块内存池实现。

### 7.1 固定块内存池（嵌入式空闲链表）

```cpp
template <uint32_t BlockSize, uint32_t MaxBlocks>
class FixedPool {
    static_assert(BlockSize >= sizeof(uint32_t), "BlockSize >= 4");
    static_assert(MaxBlocks > 0U, "MaxBlocks must be > 0");
public:
    FixedPool() : free_head_(0U), used_count_(0U) {
        /* 构造时建立嵌入式空闲链表：block[i].next = i+1 */
        for (uint32_t i = 0U; i < MaxBlocks - 1U; ++i) store_index(i, i + 1U);
        store_index(MaxBlocks - 1U, kInvalid);
    }

    void* allocate() noexcept;          /* O(1)，从链表头取块 */
    void  free(void* ptr) noexcept;     /* O(1)，归还链表头 */
    bool  owns(const void* ptr) const noexcept; /* 越界检测 */

private:
    alignas(uint32_t) uint8_t storage_[BlockSize * MaxBlocks];
    uint32_t free_head_;
    uint32_t used_count_;
    mutable std::mutex mutex_;
    static constexpr uint32_t kInvalid = UINT32_MAX;
};

static FixedPool<sizeof(FrameTask), 8> s_frame_pool;

struct FramePoolDeleter {
    void operator()(FrameTask* p) const noexcept {
        if (p != nullptr) {
            p->~FrameTask();            /* 显式析构 */
            s_frame_pool.free(p);       /* 归还内存块 */
        }
    }
};

/* 分配并构造 */
void* mem = s_frame_pool.allocate();
if (mem == nullptr) { return -RT_ENOMEM; }
auto task = std::unique_ptr<FrameTask, FramePoolDeleter>(
    new (mem) FrameTask(param)          /* placement new，零堆 */
);
task->process();
/* 作用域结束：FramePoolDeleter → ~FrameTask() + pool.free() */

template <typename T,
          size_t   BufferSize = 16,   /* 必须是 2 的幂 */
          bool     FakeTSO   = false, /* 单核 MCU 设为 true */
          typename IndexT    = size_t>
class SpscRingbuffer {
    static_assert((BufferSize & (BufferSize - 1)) == 0, "must be power of 2");
    /* 线程安全约束：
     *   生产者（Push/PushBatch）：仅一个线程/中断
     *   消费者（Pop/PopBatch）  ：仅一个线程
     *   两者不得互换角色       */
};

/* FakeTSO = true 时的 Push：relaxed 原子 + 编译器信号屏障 */
bool Push(const T& val) noexcept {
    const IndexT head = head_.load(std::memory_order_relaxed);
    if (full(head, tail_.load(std::memory_order_relaxed))) return false;
    buf_[head & kMask] = val;
    /* atomic_signal_fence：仅阻止编译器乱序，无 DMB 指令生成 */
    std::atomic_signal_fence(std::memory_order_acq_rel);
    head_.store(next(head), std::memory_order_relaxed);
    return true;
}

/* 逐个 Push N 个元素：2N 次原子操作 */
/* PushBatch N 个元素：2   次原子操作（一次读 head，一次写 head） */
void ADC_IRQHandler() {
    uint16_t buf[8];
    HAL_ADC_GetValues(buf, 8);
    g_adc_ring.PushBatch(buf, 8);  /* 高频中断（>10 kHz）下优势显著 */
}

---

## 9. 错误处理与 C/C++ 互操作

### 9.1 `expected<V, E>`：无异常的链式错误处理

`-fno-exceptions` 后构造函数不能抛异常，深层错误靠返回码传递。`expected<V, E>` 比裸返回码更清晰，比 `std::optional` 多携带错误信息，C++23 已纳入标准，C++17 可自行实现：

```cpp
template <typename V, typename E>
class expected {
public:
    static expected ok(V v)  { return expected(std::move(v), true);  }
    static expected err(E e) { return expected(std::move(e), false); }

    bool     has_value() const noexcept { return ok_; }
    const V& value()     const noexcept { return val_; }
    const E& error()     const noexcept { return err_; }

    /* 链式操作：有值则映射，否则透传错误 */
    template <typename F>
    auto and_then(F&& f) -> decltype(f(std::declval<V>())) {
        return ok_ ? f(val_) : decltype(f(std::declval<V>()))::err(err_);
    }

private:
    union { V val_; E err_; };
    bool ok_;
};

/* 使用示例：分配 + 构造，错误透传 */
enum class PoolErr { Exhausted };

expected<uint8_t*, PoolErr> alloc_frame_buf() {
    void* mem = s_frame_pool.allocate();
    if (mem == nullptr) return expected<uint8_t*, PoolErr>::err(PoolErr::Exhausted);
    return expected<uint8_t*, PoolErr>::ok(static_cast<uint8_t*>(mem));
}

auto result = alloc_frame_buf();
if (!result.has_value()) {
    rt_kprintf("[WARN] frame pool exhausted\n");
    return -RT_ENOMEM;
}

/* 统计库头文件：C/C++ 双模式兼容 */
#ifdef __cplusplus
extern "C" {
#endif

typedef long double DoubleType;

typedef struct {
    DoubleType sum;         /* Σx   */
    DoubleType sum_sq;      /* Σx²  */
    DoubleType pre;         /* 前一个样本（用于计算 delta）*/
    DoubleType max;
    DoubleType min;
    DoubleType delta_max;
    uint64_t   count;
} SimpleMean;

void       mean_reset  (SimpleMean *out);
void       mean_add    (SimpleMean *out, DoubleType x);
DoubleType mean_mean   (const SimpleMean *in);

/* 方差公式：σ² = E[X²] - (E[X])² = sum_sq/n - (sum/n)²
 * 使用 long double 规避大数相减精度损失 */
DoubleType mean_std_dev(const SimpleMean *in);

#ifdef __cplusplus
}
#endif

/* 推荐使用 */
std::sort(v.begin(), v.end());
std::find_if(v.begin(), v.end(), pred);
std::transform(a.begin(), a.end(), b.begin(), fn);
std::any_of / std::all_of / std::count_if / std::fill / std::copy