【C++ 硬核】给单片机装上“反射”：手写极简属性系统 (Property System) 自动化 CLI 开发

摘要 ：在高级语言（C#/Java）中，反射（Reflection）允许我们在运行时通过字符串名字访问变量。虽然 C++ 不原生支持反射，但在嵌入式系统中，我们可以利用模板 和多态 构建一个轻量级的属性系统。本文将演示如何通过几十行代码，实现变量的分布式注册 、自动类型转换 和统一访问接口，让你的调试终端开发效率提升 10 倍。

---

一、 痛点：手动解析的噩梦

假设你有 100 个参数需要通过串口配置（PID 参数、阈值、开关...）。

传统的 C 写法

// config.c
float pid_p;
int motor_speed;

void ProcessCmd(char* cmd, char* val_str) {
    if (strcmp(cmd, "pid_p") == 0) {
        pid_p = atof(val_str); // 还要手动选 atof 还是 atoi
    } 
    else if (strcmp(cmd, "motor_speed") == 0) {
        motor_speed = atoi(val_str);
    }
    // ... 写 100 个 else if，手都断了
}

缺点：

1. 耦合：变量定义和解析逻辑分离。删一个变量，忘了删解析逻辑，编译不报错，运行时没反应。

2. 重复 ：大量的 strcmp 和类型转换代码。

3. 难维护：代码像面条一样长。

---

二、 核心架构：类型擦除 (Type Erasure)

我们要实现的目标是：

// 在变量定义的地方，直接绑定
Property<float> p_pid_p("pid_p", &pid_p);
Property<int>   p_speed("speed", &motor_speed);

为了把 float 和 int 放在同一个链表里管理，我们需要一个基类来擦除类型。

1. 定义抽象基类 (Interface)

这个基类定义了所有属性必须具备的能力：从字符串写入 ，转换成字符串读出。

#include <cstring>
#include <cstdio>
#include <cstdlib>

class IProperty {
public:
    const char* name;     // 属性名字
    IProperty* next;      // 链表指针 (侵入式)

    IProperty(const char* n) : name(n), next(nullptr) {}
    virtual ~IProperty() {}

    // 核心接口：统一用字符串交互
    virtual bool SetFromString(const char* str) = 0;
    virtual void ToString(char* buffer, size_t len) = 0;
};

2. 定义模板子类 (Implementation)

利用模板，自动适配不同的数据类型。

template <typename T>
class Property : public IProperty {
private:
    T* m_ptr; // 持有实际变量的指针

public:
    // 构造函数：绑定变量，并自动加入链表（稍后实现）
    Property(const char* name, T* ptr) : IProperty(name), m_ptr(ptr) {
        Register(this);
    }

    // 实现 Set (从字符串转具体类型)
    bool SetFromString(const char* str) override {
        if constexpr (std::is_same_v<T, int>) {
            *m_ptr = std::atoi(str);
            return true;
        } 
        else if constexpr (std::is_same_v<T, float>) {
            *m_ptr = std::strtof(str, nullptr);
            return true;
        }
        else if constexpr (std::is_same_v<T, bool>) {
            *m_ptr = (std::strcmp(str, "true") == 0 || std::strcmp(str, "1") == 0);
            return true;
        }
        // ... 可以扩展更多类型
        return false;
    }

    // 实现 Get (从具体类型转字符串)
    void ToString(char* buffer, size_t len) override {
        if constexpr (std::is_same_v<T, int>) {
            snprintf(buffer, len, "%d", *m_ptr);
        }
        else if constexpr (std::is_same_v<T, float>) {
            snprintf(buffer, len, "%.4f", *m_ptr);
        }
        else if constexpr (std::is_same_v<T, bool>) {
            snprintf(buffer, len, *m_ptr ? "true" : "false");
        }
    }
    
    // 静态注册函数
    static void Register(IProperty* prop);
};

三、 魔法：自动注册与链表管理

为了不用手动维护一个数组，我们利用构造函数 的特性。全局对象的构造函数会在 main 之前运行，我们可以利用这一点构建一个链表。

1. 属性管理器

class PropertyManager {
public:
    static IProperty* head; // 链表头

    // 注册属性 (头插法)
    static void Register(IProperty* prop) {
        prop->next = head;
        head = prop;
    }

    // 根据名字查找属性
    static IProperty* Find(const char* name) {
        IProperty* curr = head;
        while (curr) {
            if (std::strcmp(curr->name, name) == 0) {
                return curr;
            }
            curr = curr->next;
        }
        return nullptr;
    }

    // 遍历所有属性 (用于 help 命令)
    template <typename Func>
    static void ForEach(Func func) {
        IProperty* curr = head;
        while (curr) {
            func(curr);
            curr = curr->next;
        }
    }
};

// 静态成员初始化
IProperty* PropertyManager::head = nullptr;

// 模板类中的注册函数实现
template <typename T>
void Property<T>::Register(IProperty* prop) {
    PropertyManager::Register(prop);
}

四、 实战：极简 CLI 实现

现在，我们的业务代码将变得异常干净。

1. 业务变量定义

你可以在项目的任何 .cpp 文件里定义变量，只需要加一行 Property 声明，它就会自动出现在 CLI 里。

// MotorControl.cpp
float g_Kp = 1.5f;
int   g_TargetSpeed = 0;
bool  g_Enable = false;

// 【只需这一步】：注册属性
Property<float> p_kp("kp", &g_Kp);
Property<int>   p_spd("speed", &g_TargetSpeed);
Property<bool>  p_en("enable", &g_Enable);

2. 通用的串口命令解析器

这段代码写一次，永久通用，以后加变量根本不需要改这里。

// 假设收到命令: "SET speed 100"
void OnSerialCommand(char* cmd, char* arg1, char* arg2) {
    
    if (std::strcmp(cmd, "SET") == 0) {
        // 1. 查找属性 (O(N) 链表查找)
        IProperty* prop = PropertyManager::Find(arg1);
        
        if (prop) {
            // 2. 自动转换并赋值
            prop->SetFromString(arg2);
            printf("OK: %s set to %s\n", arg1, arg2);
        } else {
            printf("Error: Unknown property '%s'\n", arg1);
        }
    }
    else if (std::strcmp(cmd, "GET") == 0) {
        IProperty* prop = PropertyManager::Find(arg1);
        if (prop) {
            char buf[32];
            // 3. 自动序列化
            prop->ToString(buf, sizeof(buf));
            printf("%s = %s\n", prop->name, buf);
        }
    }
    else if (std::strcmp(cmd, "LIST") == 0) {
        // 列出所有变量
        PropertyManager::ForEach([](IProperty* p) {
            char buf[32];
            p->ToString(buf, sizeof(buf));
            printf("- %s: %s\n", p->name, buf);
        });
    }
}

五、 硬核分析：内存与性能

1. RAM 开销

每个 Property 对象占用多少内存？

• const char* name: 4 字节

• IProperty* next: 4 字节

• vptr (虚表指针): 4 字节

• T* m_ptr: 4 字节

• 总计: 16 字节 (32位系统)。 如果你有 100 个配置项，仅占用 1.6KB RAM。对于 F103 (20KB RAM) 来说完全可以接受。

2. 性能开销

• 启动时间 : 在 main 之前会执行 100 次极快的链表插入操作，耗时可忽略。

• 查找时间: 线性遍历链表。对于 CLI 这种人机交互（100ms 级响应），遍历 100 个节点是瞬间完成的。

• 虚函数调用: 解析命令时用到了虚函数，但因为不是在电机控制的中断里跑，完全没有性能焦虑。

3. Flash 开销

模板会为 int, float, bool 各生成一份 Property<T> 的代码。但由于代码量很小（只是 atoi/snprintf 的封装），代码膨胀非常有限。

---

六、 进阶扩展

这个系统还可以继续进化：

1. 只读属性 : 在 Property 中加一个 bool is_readonly 标志，SetFromString 时检查该标志。

2. 回调函数: 在变量被修改后，自动触发回调（观察者模式）。

   // 当 speed 改变时，自动调用 UpdateMotor
   Property<int> p_spd("speed", &speed, OnSpeedChanged);

3. Flash 保存 : 遍历链表，将所有 name=value 对写入 Flash，实现配置保存功能。

---

七、 总结

通过利用 C++ 的 模板 (Templates) 和 继承 (Inheritance)，我们实现了一个嵌入式系统中的"反射层"。

1. 去中心化：变量在哪定义，就在哪注册。

2. 零样板代码 ：不用写 switch-case，不用写 atoi。

3. 可扩展性：新增类型只需特化模板，新增变量只需声明对象。

这才是 C++ 在嵌入式应用层开发的正确姿势：把脏活累活丢给编译器和架构，把简洁留给业务逻辑。