c++ - 按名称存储和引用变量列表

Question

我正在尝试创建一个库函数来存储指向各种类型(int、char、String 等)变量的指针，然后通过引用它们的名称来打印它们的值。

所以:

int a;
const char *b;
String c;
storeVar("a", &a);
storeVar("b", &b);
storeVar("c", &c);

及以后:

printVar("a");
printVar("b");
printVar("c");

这里的技巧是我不想枚举用户可能调用库的所有潜在类型；也就是说，我想使用模板在编译时根据我在 storeVar() 调用中使用的类型生成必要的代码。

如果我枚举所有可能的数据类型，我可以以相对直接(如果笨拙)的方式解决这个问题，要么使用 union 和类型枚举，要么按类型保留每个变量的单独列表......但我可以找出通用的解决方法。

有什么想法吗？我在 Arduino 平台上工作，所以我比在 PC 上更受限制(例如，Boost 可能不是一个选项)。

---

此解决方案基于 Massimiliano Janes 提供的代码，正在运行。不幸的是，unordered_map 在整个 Arduino 平台上都不可用，所以我可能无法使用它。然而，这只是一个存储细节，我相信无论变量如何存储，这种方法都会奏效。

// rst.h
#include <unordered_map>    

class Rst {    

private:
    struct variable
    {
      virtual void print_me() const = 0;
    };    

    template<typename T>
    struct variable_of_type: variable
    {
      T *var;    

      variable_of_type(T *v) : var{v} { }    

      void print_me() const override { 
        Serial.println(*var); 
      }
    };    

public:    
    template<typename T>
    void store_var(const char *name, T *v) { 
        varList[name] = new variable_of_type<T>(v);
    }    

    void print(const char *name) {
        varList[name]->print_me();
    }    

private:
    std::unordered_map<const char*, variable*> varList;
};    

---

#include "rst.h"    

Rst rst;    

int q;
int a = 0;
const char* b = "hallo";    

void setup()
{
    Serial.begin(115200);    

    Serial.println("=====");    

    rst.store_var("q", &q);    

    rst.store_var("a", &a);
    rst.store_var("b", &b);
    q = 10;
    rst.print("q");
    rst.print("a");
    rst.print("b");    

    q=15;
    rst.print("q");
}    

void loop() {
    delay(1000);
}

Answer 1

Boost 主要只是 header ，因此，除非您的平台缺乏语言级别支持，否则 boost 变体/任何/类型删除/容器应该开箱即用......

无论如何，如果您仍想编写自己的类型删除解决方案，想法是将“通用”行为封装在抽象接口(interface)后面，并让虚拟调度机制调用实际的模板化实现，例如:

struct variable
{
  virtual ~variable() = default;
  virtual void print_me() const = 0;
};

template<typename T>
struct variable_of_type:
  variable
{
  T const& var;

  variable_of_type(T const& v)
    :var{v}{}

  virtual void print_me() const override
    { std::cout << var << std::endl; }
};

template<typename T>
auto make_var(T const& v) // beware of v's lifetime !
  { return std::make_unique<variable_of_type<T>>(v); }

int main()
{
  auto a = 0;
  auto b = std::string{"hallo"};
  auto vars = std::unordered_map<std::string,std::unique_ptr<variable>>{};

  vars["a"] = make_var(a);
  vars["b"] = make_var(b);
  vars["a"]->print_me();
  vars["b"]->print_me();
}

更准确地说，一个真正的类型删除解决方案会将 unique_ptr 层隐藏在一些常规类型后面(例如，参见 std::any 、 std::function<void()> ，...)，无论如何，我希望你得到了基本的想法...