时间戳

首页 > 解决方案 > 对于管理指向不同类型的指针的类，最直观的布局是什么？

c++ - 对于管理指向不同类型的指针的类，最直观的布局是什么？

问题描述

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

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)));

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

有没有更好，更简单的方法来完成所有这些，或者我现在拥有的系统是否足够？

标签： c++

解决方案

好吧，从技术上讲，您可以跳过在呼叫站点分配它们...

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);
}

推荐阅读