对于管理指向不同类型的指针的类来说，最直观的布局是什么

Question

我有一个管理字符串和指针映射的类，如下所示：

class DebugTab
{
public:
void pushItem(std::string&& name, std::unique_ptr<DebugItem> item);
private:
std::map<std::string, std::unique_ptr<DebugItem>> items_;
};

指针应该能够指向不同的类型，所以为了实现这一点，我制作了一个简单的抽象类：

class DebugItem
{
public:
virtual std::string asString() = 0;
};

然后为基本类型创建了一些派生类：

class DebugInt : public DebugItem
{
public:
DebugInt(int& i) : i_(i) {}
std::string asString() override {return std::to_string(i_);}
private:
int& i_;
};
class DebugFloat : public DebugItem
{
public:
DebugFloat(float& f) : f_(f) {}
std::string asString() override {return std::to_string(f_);}
private:
float& f_;
};
class DebugString : public DebugItem
{
public:
DebugString(std::string& s) : s_(s) {}
std::string asString() override {return s_;}
private:
std::string& s_;
};

我的想法是，使用DebugTab的人会使用"new"在堆上创建具有正确类的项，然后将指针传递给pushItem，如下所示：

DebugTab tab;
int var1;
float var2;
std::string var3;
tab.pushItem("var1", std::move(std::make_unqiue<DebugInt>(var1)));
tab.pushItem("var2", std::move(std::make_unique<DebugFloat>(var2)));
tab.pushItem("var3", std::move(std::make_unique<DebugString>(var3)));

我对这个解决方案不太满意。我觉得把堆指针传递给一个跟踪已经创建的变量的类不是很直观。

有没有更好、更简单的方法来做这一切，或者我现在的系统足够了？

Answer 1

从技术上讲，您可以跳过在callsite分配它们。。。

template<class T>
struct DebugConcrete: DebugItem {
T &t;
std::string asSring() const override {
return std::to_string(t);
}
};
class DebugTab {
template<class T>
void pushItem(std::string name, T &item) {
items_.emplace(std::move(name),
std::make_unique<DebugConcrete<T>>(item));
}
};
#define pushItem(...) pushItem(#__VA_ARGS__, __VA_ARGS__)
int main() {
int i;
DebugTab tab;
tab.pushItem(i);
}