c++使用字符串句柄对对象进行通用存储和检索

Question

什么是优雅和简单的方式(如果存在)来实现通用对象的存储(所有其他对象都继承自 base)。存储对象后，使用字符串句柄检索对象或复制到另一个对象。

class Object{
    public:
        Object(){};
        ~Object(){};
};

class ObjectHandler{
    public:
        ObjectHandler(){};
        ~ObjectHandler(){};
        void InsertObject(std::string handle, std::shared_ptr<Object> obj){
            // some things happen before inserting
            _obj.insert(std::make_pair(handle,obj));
        }
        std::shared_ptr<Object> RetrieveObject(std::string handle){
            // some things happen before retrieving
            return _obj[handle];
        }
    private:
        std::map<std::string,std::shared_ptr<Object>> _obj;

}

例如，用户定义的类是

class Dog : public Object{
    public:
        Dog(){};
        Dog(std::string name){dogName=name};
        ~Dog(){};
        std::string dogName;
        //...
}

class Cat : public Object{
    public:
        Cat(){};
        Cat(std::string name){catName=name};
        ~Cat(){};
        std::string catName;
        //...
}

然后执行下面的代码

void main(){
    ObjectHandler oh;
    Cat c("kitten"), cc;
    Dog d("doggy"), dd;

    oh.InsertObject("cat#1",c);
    oh.InsertObject("dog#1",d);

    cc = oh.RetrieveObject("cat#1");
    dd = oh.RetrieveObject("dog#1");

    std::cout << cc.catName << std::endl; // expect to print 'kitten'
    std::cout << dd.dogName << std::endl; // expect to print 'doggy'
}

我相信应该有一些完善的想法(模式)来使这项工作正常进行。

我还怀疑 std::shared_ptr 在这里可能会有用。

谢谢，

Answer 1

我会在这里谨慎行事，在您的示例中，您严格地将对象存储为 Object (在堆栈上)，因为这只会为 Object< 类型的东西分配足够的空间/strong>，如果您插入从该类型继承的内容，它会将描述子类的部分切片。

手头问题的好例子:

• http://www.geeksforgeeks.org/object-slicing-in-c/
• What is object slicing?

解决该问题的一种方法是在您的 ObjectHandler 中处理指向对象的指针，而不是对象本身分配在堆上。

如果我只是误解了您的帖子，那么我深表歉意。

但是如果你像你所说的那样，将存储指向对象的智能指针，那么一对应该看起来像这样:

std::map<std::string,std::shared_ptr<Object>> _obj;;
std::string handle = "hello"; //Or whatever the actual handle is.
std::shared_ptr<Object> keyvalue(new Object());

objects[handle] = std::shared_ptr<Object>(keyvalue); //alternative to std::make_pair
objects.insert(std::make_pair(handle, std::shared_ptr<Object>(keyvalue))); //this also works

根据您希望在什么时候开始使用智能指针处理对象，插入可能如下所示:

    void InsertObject(std::string handle, Object* obj){
        _obj.insert(std::make_pair(handle,std::shared_ptr<Object>(obj)));
    }

    std::string key("hi");
    InsertObject(key, new Object());

或者只是:

    void InsertObject(std::string handle, std::shared_ptr<Object> obj){
        _obj.insert(std::make_pair(handle, obj));
    }

另请注意，如果旧值存在，std::map 的索引运算符[] 将覆盖旧值，而您已经使用的插入将仅在旧值不存在时才插入。