Question

我从基类继承了几个不同的类。基层知道谁继承了他。

我的任务是将其存储在某些队列中，稍后再恢复数据。

这是我能想到的最好的方法

#include <iostream>
#include <queue>

enum class type{
    some = 0,
    other
};

struct Base{
    const type Type;
    Base(type t): Type(t) {};
};

struct Some : public Base {
        int SomeData;
        Some(): Base(type::some) {};
};

struct Other : public Base {
        int OtherData;
        Other(): Base(type::other) {};
};


std::queue<Base*> baseQueue;

void Store() {
    Some *s = new Some();
    s->SomeData = 1;

    Other *o = new Other();
    o->OtherData = 2;

    baseQueue.push(s);
    baseQueue.push(o);

}

void Process() {
    while (!baseQueue.empty()) {
        Base *b = baseQueue.front();
        if (b->Type == type::some) {
            Some *ps = (Some*) b;
            std::cout << "Some data: " << ps->SomeData << '\n';
        } else {
            Other *po = (Other*) b;
            std::cout << "Other data: " << po->OtherData << '\n';
        }
        delete b;
        baseQueue.pop();
    }
}


int main() {
    Store();
    Process();

    return 0;
}

它看起来很丑，因为：

我使用指针。
new和delete在不同的部分（以实际代码-不同的单位）。有人可以像Some s; baseQueue.push(&s)这样推入队列，而我将在delete失败。不知道如何避免这种情况。
我不知道为什么没有内存泄漏（我只删除Base*而不是Some*或Other*）
这甚至看起来都不像c ++。

所以。我的问题是在这种情况下的惯例是什么？也许解决这类问题的容器已经存在，而我在谷歌搜索中很糟糕？

将具有相同基准的不同对象存储在单个队列中

0 个答案: