Can you delete a pointer without newing it up?

[asimorio]

Hi all,
If I don't new up a pointer, can I delete it?
see code below:

void A::foo()
{
char* buffer;
delete buffer;
return;
}


regards,
Vynce

 

[Rolf Magnus]

Hi all,
If I don't new up a pointer, can I delete it?

Well, you can, but the behavior will be undefined unless the pointer was a
null pointer. In that case, nothing is done.

 

[Ian Collins]

Hi all,
If I don't new up a pointer, can I delete it?
see code below:

void A::foo()
{
char* buffer;
delete buffer;

You can try, but your toilet might explode.

 

[=?ISO-8859-1?Q?Jens_M=FCller?=]

Hi all,
If I don't new up a pointer, can I delete it?
see code below:

void A::foo()
{
char* buffer;
delete buffer;
return;
}

No you can't, the behaviour of your

delete buffer;

is undefined.

What exactly is the purpose of that code?

 

[uraniumore235]

Now lets think about it. When you instantiate a pointer variable, you
obviously want to point it to some defined memory location. Since you
did not new-up or NULL-up a memory location, the pointer basically has
an undefined property. When you delete this pointer variable, which has
an undefined property, you are basically telling the compiler to return
the pointed to location ??? to the heap stack. Does this even make
sense? No!

 

[asimorio]

Well, now i modify a bit my code:
Will it make sense?

void A::Foo(void* a)
{
char* buffer = (char*) a;
delete buffer;
return;
}


regards,
Vynce

 

[Rolf Magnus]

Now lets think about it. When you instantiate a pointer variable, you
obviously want to point it to some defined memory location. Since you
did not new-up or NULL-up a memory location, the pointer basically has
an undefined property. When you delete this pointer variable, which has
an undefined property, you are basically telling the compiler to return
the pointed to location ??? to the heap stack. Does this even make
sense? No!

That reminds me of the Chewbacca defense

 

[Rolf Magnus]

Well, now i modify a bit my code:
Will it make sense?

void A::Foo(void* a)
{
char* buffer = (char*) a;
delete buffer;
return;
}

Yes, as long as A::Foo is only called with a pointer that points to a single
char allocated with new.

 

[Ian Collins]

Well, now i modify a bit my code:
Will it make sense?

void A::Foo(void* a)
{
char* buffer = (char*) a;
delete buffer;
return;
}

Even if your toilet doesn't explode, you program will surely crash. You
are telling delete to free memory that doesn't belong to the heap.

 

[Ian Collins]

Even if your toilet doesn't explode, you program will surely crash. You
are telling delete to free memory that doesn't belong to the heap.

Oops, didn't see the pointer passed in as a parameter.

 

[Rolf Magnus]

Yes, as long as A::Foo is only called with a pointer that points to a
single char allocated with new.

.... or a null pointer.

 

[Tomás]

asimorio posted:

Hi all,
If I don't new up a pointer, can I delete it?
see code below:

void A::foo()
{
char* buffer;
delete buffer;
return;
}

Think of "new" as a function which returns the address of the object it
creates:

char *new();

Think of "delete" as a function which takes as an argument the address of
the object which was created:

void delete( char * );


The first line of your code defines a local variable without initialising
it. "buffer" contains white noise. It may contain the memory address
70470980, or it may contain the memory address 9327052, or it may contain
the memory address 27696368.

Now you pass this address to "delete". Bottom line is this:

You can only give "delete" an address which was returned from "new",
otherwise it's undefined behaviour.
You can only give "delete []" an address which was returned from "new
[]", otherwise it's undefined behaviour.

Of course, the exception to this is that you can safely give "delete" or
"delete []" a null pointer, and it will have no effect:

delete static_cast<char*>(0);
delete [] static_cast<char*>(0);


-Tomás