Question

如果我有一个指向应该分配的对象的映射，但是其他一些调用者会插入指向超出范围的对象的指针，该怎么办？考虑到您可以通过两种方式添加对象指针：

class MyClass {
    public:
        std::map<int, MyObject*> myMap;
        MyClass();
        ~MyClass();
};
MyClass::MyClass(){}
MyClass::~MyClass(){
    std::map<int, MyObject*>::iterator it;
    for(it = this->myMap.begin(); it != this->myMap.end(); it++){
        delete it->second;
    }
}

案例1 - 引用超出范围的对象

MyObject myObject;
ptrMyClass->myMap.insert(std::make_pair(0, &myObject));

案例2 - 按分配的对象

MyObject myObject = new MyObject();
ptrMyClass->myMap.insert(std::make_pair(0, myObject));

这样做是明智的吗？

for(it = this->myMap.begin(); it != this->myMap.end(); it++){
     if(sizeof(it->second) == sizeof(MyObject)){
         delete it->second;
     }
 }

它至少会避免无内存错误，如果我最后清除，是否涵盖所有情况？是否有可能首先避免这种情况？（我使用C ++ 98）

Answer 1

首先是这段代码：

if(sizeof(it->second) == sizeof(MyObject)){

等于：

if(sizeof(MyObject*) == sizeof(MyObject)){

所以你要么不删除任何一个，要么你的对象的大小突然等于指针你删除它们。在C ++中，没有办法只有一个指针来确定对象是否是动态分配的。所以你基本上有两个选择：

1 Always own objects - when you have automatic aka scoped objects make a dynamically allocated copy.

2 Store additional information if you own the object or not, you can do that either by smart pointers or storing a flag together with pointer.

Answer 2

解决方案将是智能指针。由于您使用C ++ 98，我已经包含了一个可能的实现。

template <typename t>
class auto_ptr
{
  private:
    t *_ptr;

  public:
    auto_ptr(t *ptr) : _ptr(ptr){};

    auto_ptr(auto_ptr<t> &lhs) : _ptr(lhs._ptr)
    {
        lhs._ptr = NULL;
    };

    ~auto_ptr()
    {
        if (_ptr != NULL)
        {
            delete _ptr;
        }
    };

    auto_ptr<t> &operator=(auto_ptr<t> &lhs)
    {
        _ptr = lhs._ptr;
        lhs._ptr = NULL;
        return *this;
    };

    t *get()
    {
        return _ptr;
    };
};

将指针混合到已分配的对象和范围对象

2 个答案: