deleting an object twice?

[Rick]

Hi,

Does deleting an object more than one times incur undefined behavior? I
think it doesn't but just making sure... thanks

Rick

[Karl Heinz Buchegger]

Rick wrote:

Hi,

Does deleting an object more than one times incur undefined behavior?
The first delete renders the pointer to it invalid. Using an
invalid pointer invokes undefined behaviour.
I
think it doesn't but just making sure... thanks

You are wrong.
--
Karl Heinz Buchegger
kb******@gascad .at

[Ali R.]

"Rick" <rrquick@nosp am-com> wrote in message
news:3f******** @clarion.carno. net.au...

Hi,

Does deleting an object more than one times incur undefined behavior? I
think it doesn't but just making sure... thanks

Rick

Are you setting your pointer to null after the first delete? I think you
have deleting a null pointer mixed up with deleting a pointer twice. I am
not sure if this is a standard behavior or not but on the few compilers that
I have worked with delete checks for a null pointer and does nothing.

[Hendrik Belitz]

Rick wrote:

Hi,

Does deleting an object more than one times incur undefined behavior? I
think it doesn't but just making sure... thanks

Rick

It does. Delete renders a pointer to be invalid and so calling delete again
will result in undefined behaviour. To circumvent this, simply set the
pointer to NULL after deletion. Calling delete for a NULL pointer will do
nothing.

--
Dipl.-Inform. Hendrik Belitz
Central Laboratory of Electronics
Research Center Juelich

[tom_usenet]

On Fri, 05 Dec 2003 03:08:58 +1100, Rick <rrquick@nosp am-com> wrote:

Hi,

Does deleting an object more than one times incur undefined behavior? I
think it doesn't but just making sure... thanks

int* p = new int;
delete p;
delete p; //undefined behaviour

Generally double deletes cause heap corruption and, if you're lucky, a
crash. You can of course delete null pointers as often as you like.
e.g.

int* p = new int;
delete p;
p = 0;
delete p; //fine

Tom

C++ FAQ: http://www.parashift.com/c++-faq-lite/
C FAQ: http://www.eskimo.com/~scs/C-faq/top.html

[Andrew Koenig]

> Does deleting an object more than one times incur undefined behavior? I

think it doesn't but just making sure... thanks

How can you possibly delete an object more than once? Once you have deleted
it, it no longer exists, so what are you deleting the second time?

If you are thinking of something like this:

int* p = new int;
delete p;
delete p;

then after the first "delete p", p is an invalid pointer -- the only thing
you can do with p is give it a new value.

So there is no question of deleting "an object" twice.

[E. Robert Tisdale]

Andrew Koenig wrote:

Does deleting an object more than one times incur undefined behavior?
I think it doesn't but just making sure... thanks
How can you possibly delete an object more than once?
Once you have deleted it, it no longer exists,
so what are you deleting the second time?

If you are thinking of something like this:

int* p = new int;
delete p;
delete p;

then after the first "delete p", p is an invalid pointer --

I object to your abuse of the English language.
The pointer p is *not* deleted.
The *object* to which pointer p points is deleted.
Pointer p is a valid pointer to an invalid object
(of type int in this case) because delete calls
the object's destructor to destroy the object.
the only thing you can do with p is give it a new value.

So there is no question of deleting "an object" twice.

The problem is that the second delete
is almost certainly a programming error -- a bug.
If you simply set the pointer p = NULL,
the bug will go undetected.
You can't do anything about this for built-in types
but you can for User Defined Types (UDTs):

class X {
private:
int Valid;
// other data members
public:
X(void) Valid(0x5555555 5) { }
~X(void) {
if (0x55555555 == Valid)
Valid == 0xaaaaaaaa;
else
std::cerr << "Invalid object of type X!" << std::endl;
}
// other public functions and operators
};

[David White]

"E. Robert Tisdale" <E.************ **@jpl.nasa.gov > wrote in message
news:3F******** ******@jpl.nasa .gov...

Andrew Koenig wrote:

Does deleting an object more than one times incur undefined behavior?
I think it doesn't but just making sure... thanks
How can you possibly delete an object more than once?
Once you have deleted it, it no longer exists,
so what are you deleting the second time?

If you are thinking of something like this:

int* p = new int;
delete p;
delete p;

then after the first "delete p", p is an invalid pointer --

I object to your abuse of the English language.
The pointer p is *not* deleted.

Who said it was?
The *object* to which pointer p points is deleted.
As far as I can see, neither the OP nor AK have stated or implied that it is
the pointer being deleted. Only the C++ source code says that :-)
Pointer p is a valid pointer to an invalid object
(of type int in this case) because delete calls
the object's destructor to destroy the object.

the only thing you can do with p is give it a new value.

So there is no question of deleting "an object" twice.

The problem is that the second delete
is almost certainly a programming error -- a bug.
If you simply set the pointer p = NULL,
the bug will go undetected.

I'd say that would fix the bug rather than hide it, albeit unsatisfactoril y.
And in some circumstances two deletes are quite normal. An object's member
pointer to a valid object might or might not have been deleted and assigned
to null before the destructor is reached, so you would like the destructor
to delete it regardless.

DW

[Peter van Merkerk]

"E. Robert Tisdale" <E.************ **@jpl.nasa.gov > wrote in message
news:3F******** ******@jpl.nasa .gov...

Andrew Koenig wrote:

Does deleting an object more than one times incur undefined behavior?
I think it doesn't but just making sure... thanks
How can you possibly delete an object more than once?
Once you have deleted it, it no longer exists,
so what are you deleting the second time?

If you are thinking of something like this:

int* p = new int;
delete p;
delete p;

then after the first "delete p", p is an invalid pointer --

I object to your abuse of the English language.
The pointer p is *not* deleted.

I don't think Andrew said so; he just said: "after the first "delete p"". He
didn't say that the pointer was deleted.
The *object* to which pointer p points is deleted.
Pointer p is a valid pointer to an invalid object
(of type int in this case) because delete calls
the object's destructor to destroy the object.

the only thing you can do with p is give it a new value.

So there is no question of deleting "an object" twice.
The problem is that the second delete
is almost certainly a programming error -- a bug.
If you simply set the pointer p = NULL,
the bug will go undetected.

It is not necessarilly a bug. There is a reason why you can do a delete on a
null pointer.
You can't do anything about this for built-in types
but you can for User Defined Types (UDTs):

class X {
private:
int Valid;
// other data members
public:
X(void) Valid(0x5555555 5) { }
~X(void) {
if (0x55555555 == Valid)
Valid == 0xaaaaaaaa;
else
std::cerr << "Invalid object of type X!" << std::endl;
}
// other public functions and operators
};

Even though this technique may work on some platforms with some compilers
under certain circumstances, it is not *guaranteed* to work. Once an object
has been deleted, the memory it occupied may have been overwritten, unmapped
(resulting in a page fault) or occupied by another object (possibly of the
same class). There is also a chance the vtable pointer of the deleted object
is damaged; if the pointer is used to call any virtual member function
(including the destructor) on the deleted object very weird things may
happen - good for hours of debugging fun.

Personnally I prefer resetting the pointer to NULL after deleting the object
it is pointing to. That way it easy to detect if the pointer is still
pointing to a valid object, and on most platforms leads to very predictable
behaviour when that pointer is accidentally dereferenced. Resetting the
pointer does not conflict with using a member variable to see if the object
is still valid. Even tough that technique is not 100% reliable, it increases
the chance that code that shouldn't work doesn't work (which is usually a
good thing). Member functions (not just the destructor) can use the member
variable with the magic number as a precondition. This technique can be
especially useful to detect lifetime issues i.c.w. having multiple pointers
to the same object.
--
Peter van Merkerk
peter.van.merke rk(at)dse.nl

[Andrew Koenig]

How can you possibly delete an object more than once?
Once you have deleted it, it no longer exists,
so what are you deleting the second time?

If you are thinking of something like this:

int* p = new int;
delete p;
delete p;

then after the first "delete p", p is an invalid pointer --
I object to your abuse of the English language.

That's your prerogative. Mine is to say that you're mistaken :-)
The pointer p is *not* deleted.
I never said it was.
The *object* to which pointer p points is deleted.
Yes, that's what I said.
Pointer p is a valid pointer to an invalid object
(of type int in this case) because delete calls
the object's destructor to destroy the object.
Wrong. Once you have said "delete p", the value of p is now invalid. For
example, in

int* p = new int;
delete p;
int* q = p;

the attempt to copy p in order to initialize q yields undefined behavior, so
the implementation can do as it pleases.

the only thing you can do with p is give it a new value. So there is no question of deleting "an object" twice.

The problem is that the second delete
is almost certainly a programming error -- a bug.
Yes, indeed -- I never said otherwise.
If you simply set the pointer p = NULL,
the bug will go undetected.
Yes indeed -- I never said otherwise.
You can't do anything about this for built-in types
but you can for User Defined Types (UDTs):

class X {
private:
int Valid;
// other data members
public:
X(void) Valid(0x5555555 5) { }
~X(void) {
if (0x55555555 == Valid)
Valid == 0xaaaaaaaa;
else
std::cerr << "Invalid object of type X!" << std::endl;
}
// other public functions and operators
};

And your point is what, exactly? Are you claiming that C++ requires some
particular behavior in the case of

X* p = new X;
delete p;
delete p;

It doesn't; the implementation can do as it pleases.