混合指向已分配对象和作用域对象的指针

Question

What if I have a map that points to objects that are supposed to be allocated, but some other caller inserts a pointer to an object that will go out of scope? Considering you can add object pointers in two ways:

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

Case 1 - by reference for objects that will go out of scope

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

Case 2 - by allocated objects

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

Is it sensible to do this?

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

It will at least avoid a memory free error, and if I clear at the end, does it cover all cases? Is it possible to avoid this situation in the first place? (I use C++98)

Answer 1

First of all this code:

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

is equal to this:

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

so you either would not delete any, or if size of your object suddenly equal to a pointer you delete them all. In C++ there is no way by having only a pointer to determine if object is allocated dynamically or not. So you basically have 2 options:

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

The solution would be smart pointers. Since you use C++98, I've included a possible implementation.

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