When to use "delete"?

Question

I want to store 10 Obj object in objList, but i don't know when is appropriate use delete in this case. If i use delete Obj; in the line where i note in below code, will the Obj still be stored in objList?

struct Obj {
    int u;
    int v;
};

vector<Obj> objList;

int main() {
    for(int i = 0; i < 10; i++) {
        Obj *obj = new Obj();
        obj->u = i;
        obj->v = i + 1;
        objList.push_back(*obj);
        // Should i use "delete Obj;" here? 
    }
}

`new` is not required at all here..create the object on stack using `Obj obj;`. — Naveen, Mar 27 '12 at 11:15
And even if you did need `new`, then a simple `delete` wouldn't be sufficient - if `push_back` throws, then you've got a leak. You should always use [smart pointers](http://stackoverflow.com/questions/106508) or other [RAII](http://stackoverflow.com/questions/76796) objects to manage dynamic resources. — Mike Seymour, Mar 27 '12 at 11:57

score 9 · Answer 1 · answered Mar 27 '12 at 11:14

Yes, you should.

There should be a corresponding delete for every new in your program.

But your program doesn't need dynamic allocation:

Obj obj;
obj.u = i;
obj.v = i + 1;
objList.push_back(obj);

Also, your syntax was wrong - objList.push_back(*Obj); // should be *obj, not *Obj

Konrad · Accepted Answer · 2012-03-27T11:31:29.973

9

Any object you create on the heap with new needs to be cleared up by delete. In your code, you are actually storing a copy in your collection.

objList.push_back(*Obj);

What this line is doing step by step is:

Indirecting a pointer to the underlying heap memory Obj occupies (returning the object Obj)
Calling the copy constructor to create a temporary copy
Storing the temporary copy in the collection

You do not need to create this initial Obj on the heap, a stack allocated local will suffice as @Luchian Grigore has pointed out.

Obj obj;
objList.push_back(obj);

You do not need to call delete on the copy in the collection, the STL collection will handle this memory itself when you remove the element, but you still will need to delete the original heap allocated object.

It would be better if you stored your objects by std::shared_ptr. That way delete would be called when all references to the Obj were removed.

std::vector< std::shared_ptr< Obj > > vec;
vec.push_back( std::make_shared( new Obj() ) );

edited Mar 27 '12 at 11:31

answered Mar 27 '12 at 11:16

Konrad

39,751
32
78
114

I was trying to point out the lifetime of the object in the heap space allocated by the collection doesn't have to be managed by the OP. :-) – Konrad Mar 27 '12 at 11:23
Also, it's not stack and heap, but automatic and dynamic storage. – Luchian Grigore Mar 27 '12 at 11:24
@Konrad, you mean when i use `objList.push_back(*obj);`, we store a "copy" of `*obj` in objList. So we don't have to worry about deleting obj. Is my understanding right? – LoveTW Mar 27 '12 at 11:30
@Mr.mr.: your understanding is wrong: in your code, you "newed" an Obj pointed to by obj, so you must delete it. you don't have to worry about the copy of that Obj object. – stefaanv Mar 27 '12 at 11:58

score 3 · Answer 3 · answered Mar 27 '12 at 11:19

Think about what happens:

In your loop you create a new instance of Obj and assign some values to it. This instance is created on your heap - thus you have to free it afterwards. When you add the instance to the vector you implicitely create a copy of it - because you have a vector of objects, not of pointers. Thus the vector keeps its own copy of Obj. You are safe to delete your Obj instance.

BTW:

you could even reuse the object instance and create and free it outside of your loop
it's not necessary to allocate the Obj instance on the heap

Obj x; x.u =i; x.v = i+1; objList.push_back(x);

would also do

You should read some articles about smart pointers and smart pointer containers. Eg. boost::scoped_ptr, boost::shared_ptr, std::auto_ptr. Using these paradigms there's usually no need to call delete by yourself.

score 2 · Answer 4 · edited Aug 10 '14 at 17:00

You wanna use the heap, so I suggest changing your vector declaration to vector of pointers, something like this.

vector<Obj *>objList;

Why? Because if it is a vector of Obj's, then the things you're storing are actually copies of the value Obj of the pointers you created. objList's items and the obj pointers you create are totally separated and unrelated! So when you,

delete obj

The things on objList are totally completely unaffected in any ways.
Moreover, vector<Obj> (no asterisk), stores its item as Obj and they are on the stack, they will disappear when your program goes out of scope!

score 1 · Answer 5 · answered Mar 27 '12 at 13:31

Well, the simple rule is that each variable constructed by new should be clean up by delete.

However depending on your goal, you may not need write the delete yourself.

At home, when learning the gory details of memory management, you will probably write as many delete as you write new.

Professionals, however, never use delete in applicative code (*). delete is a code smell. It's the shortest way to memory leaks in the presence of exceptions. Professionals use RAII to deal with exceptions safely, and namely: smart pointers/smart containers.

(*) as opposed to library code, ie someone wrote that shared_ptr class one day.

When to use "delete"?

5 Answers5

Linked

Related