Re: Passing Pointers -- where to delete them
On 2 mar, 18:24, "jason.cipri...@gmail.com" <jason.cipri...@gmail.com>
wrote:
On Mar 2, 11:29 am, Arv <arvind.b...@gmail.com> wrote:
I am creating a new object on the heap using new. Now if I pass this
pointer to any function, is it okay to assume that the function can
delete that pointer, or should I delete the pointer in my function
only.
In general, you should try to only delete objects in the
"opposite" of the code that you create them in.
If you can do this, why use dynamic allocation?
For example, if you have a function
like this:
void function () {
Object *obj = new Object;
// do something with obj
delete obj;
}
There you instantiate Object at the beginning of the function,
so it makes sense to delete the object at the end of the
function.
In such a case, the ONLY thing which makes sense is:
void function()
{
Object obj ;
// ...
}
No new, no delete.
If for some reason, you must use dynamic allocation (e.g.
polymorphism), then you absolutely should use a scoped_ptr here.
But such cases are, in my experience, exceedingly rare, and not
something a beginner is likely to encounter. (The code, as you
have written it, is incorrect, and will leak memory, and
possibly have other untoward effects, in the case of an
exception.)
Or
something like this:
void function () {
Object *obj1 = new Object;
if (...) {
Object *obj2 = new Object;
...
delete obj2;
}
delete obj1;
}
Ditto.
There it makes sense to delete the Objects just before they go
out of the scope they were created in. Likewise, if you
allocate objects in the constructor of some class, it makes
sense to delete them in the destructor:
class Something {
public:
Something () {
m_object = new Object;
}
~Something () {
delete m_object;
}
private:
Object *m_object;
};
Again, why the pointer? (In this case, there are justifications
in specific cases, e.g. the compilation firewall idiom. But
globally, I'd say that given the questions being asked, the
original poster isn't there yet. And of course, in modern code,
you might just use boost::scoped_ptr to implement the
compilation firewall, and not write any delete at all.)
Or if you have some initialization function that allocates
objects, it makes sense to destroy those objects in the
corresponding "cleanup" function.
The reason I say it's "good" to do it this way in general is
just because, at least when you are just starting to get the
hang of it, following simple sets of rules like that makes it
easier to keep track of what is going on. In reality, there
are many, many different idioms you can follow for object
creation and destruction.
The important thing to keep in mind is that dynamic allocation
is used first and foremost to give objects an explicit lifetime.
Anytime the lifetime is defined by scope in some way, you really
should consider not using dynamica allocation at all.
Really you need to keep a few things in mind:
1) How long does this object need to live? When will it be
safe to destroy it?
Or when do you have to destroy it? Many, probably most,
dynamically allocated objects have explicit lifetimes, which
have to be respected. You destruct the object when the
information model you are implemented says to destruct it.
Whether it's safe to or not:-). (Seriously, not destructing it
at that moment would be a programming error. So you write the
code to ensure it will be safe, e.g. using the observer
pattern.)
2) Things must happen in a known order -- do not construct
code that has the risk of using an object before it is
instantiated, or after it has been destroyed. Take care not to
construct code that destroys an object that has already been
destroyed. One good rule of thumb here is to try to always
clean things up in the reverse order that you have created
them (you don't *have* to do it this way but it makes sense in
many situations), for example:
ObjectA *obja = new ObjectA();
ObjectB *objb = new ObjectB(obja); // maybe this depends on obja
initialize_something(obja, objb); // a made up function
// do stuff; then cleanup in reverse:
cleanup_something(obja, objb);
delete objb;
delete obja;
3) Documentation and comments helps a lot; for example:
// note: do not delete Objects that you pass to this
// function, it will take care of deleting them for
// you!
void function1 (Object *obj);
// note: the caller may safely delete the object
// passed to this function immediately after calling
// it.
void function2 (Object *obj);
Documentation is essential, but typically, you can assume by
default that a function does not delete something that is passed
to it, UNLESS that is part of its role.
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34