Thread: Deleting Pointers?

1. 1. You are not properly allocating memory.
   2. You are setting the pointer in someFunction() to 0 before deleting it, which means you are deallocating nothing.
   3. If you set somePtr to any value in someFunction(), such a change is not reflected in myPtr in main() (in terms of what the pointer value is.)
   4. Deleting memory in a function is allowed in the manner that you have (provided you fix the setting-to-0-first error). Such memory should not be accessed anywhere else after being deallocated.
2. 1. You're not allocating memory for myPtr2.
   2. You delete it in the calling function..... ie.
      
      Code:

      AnotherObject *o = someFunction();
      ...
      delete o;

Originally Posted by MacGyver

1. You're not allocating memory for myPtr2.
2. You delete it in the calling function..... ie.
   
   Code:

   AnotherObject *o = someFunction();
   ...
   delete o;

1. Yeah I forgot the, "= new Object()" lines for this post, but I do it in my program

2. Oh yeah, of course!

Originally Posted by MacGyver

1. You are not properly allocating memory.
2. You are setting the pointer in someFunction() to 0 before deleting it, which means you are deallocating nothing.
3. If you set somePtr to any value in someFunction(), such a change is not reflected in myPtr in main() (in terms of what the pointer value is.)
4. Deleting memory in a function is allowed in the manner that you have (provided you fix the setting-to-0-first error). Such memory should not be accessed anywhere else after being deallocated.

2. Hmm? Don't set to 0 first?

The address in memory it's pointing to is different from the memory where the pointer actually is. So there's two steps to do, no? Change pointer->address, then delete the variable pointer completely?

[Edit]: I just tried it in my program, and if I don't set it to 0 first, it seg faults immediately. Are you sure?

I just tried it in my program, and if I don't set it to 0 first, it seg faults immediately. Are you sure?

If the pointer is 0, then delete does nothing at all. You don't delete pointers, you delete what the pointer is pointing at.

If it segfaults otherwise it means that you are not giving delete a valid pointer (it has not been allocated with new or the memory has been already deleted).

Originally Posted by anon

If the pointer is 0, then delete does nothing at all. You don't delete pointers, you delete what the pointer is pointing at.

If it segfaults otherwise it means that you are not giving delete a valid pointer (it has not been allocated with new or the memory has been already deleted).

Ok wait. I think I have been using delete entirely wrong then in my entire program...

Let's say you do:

Code:

Object* myPtr1 = new Object();

Object* myPtr2 = myPtr1;

delete myPtr2;

What does the delete do?

A1) myPtr2 wasn't created using "new", so it will give a seg fault???

A2) If so, what is the proper way to deallocate myPtr2?

-----

Another question:

If I do

Code:

Object* myPtr1 = new Object();

myPtr1 = 0;

delete myPtr1; //Useless?

B1) The delete line does nothing?

B2) Would this cause a memory leak because the object is still in memory somewhere?




(Sorry for all the edits, just trying to make it more readable hehe)

Originally Posted by Paul22000

Ok wait. I think I have been using delete entirely wrong then in my entire program...

Let's say you do:

Code:

Object* myPtr1 = new Object();

Object* myPtr2 = myPtr1;

delete myPtr2;

What does the delete do?

myPtr2 wasn't created using "new", so it will give a seg fault?

It will be fine - just don't try to delete myPtr1 as well, because then you do "double delete", since myPtr1 points to the same piece of memory.

-----

Another question:

If I do "myPtr1 = 0; delete myPtr1"

A) The delete does nothing? And B) it's a memory leak because the object is still in memory somewhere?

Delete itself does nothing. Whether it means that you leak memory or not depends on what myPtr1 was before it was set to 0. If it pointed to memory that came from new, then you would indeed be leaking that memory.

--
Mats

Let's put it this way...
When you use new, you are creating a new house out there in the wide world, somewhere.
New then returns the address where that house is located.
If you assign ptr1 to ptr2, then ptr2 also holds the address where the house is located.
When you call delete, the bulldozer drives to the address in the pointer you give it and demolishes the house.
So if you call delete on ptr1, then what happens to ptr2? Easy. Ptr2 just holds the address of the (now) demolished house! So ptr2 (as well as ptr1) is now invalid.
If you call delete on ptr2 after ptr1 now, the bulldozer will try to demolish an already demolished house (which, in the computer world, is a big no-no).
If you set the pointer to 0 before calling delete, the bulldozer can't find the house anymore. Its address is lost and you get a memory leak.

The concept is that pointers contains the address and no the house (object) itself.

If you call delete on ptr2 after ptr1 now, the bulldozer will try to demolish an already demolished house (which, in the computer world, is a big no-no).

To continue your analogy:

Worse is that another 'new' may have built a new house at that address, and now deleting ptr2 may demolish another object's house creating a very hard to diagnose/debug problem.

Agreed. Good analogy.

Do I just not do anything with them at the end of the sorting function?

Correct.

Just declaring a pointer, and setting it to point at memory allocated for another variable, does not use any memory. In your case, you don't have to free or delete currentNode at all.

Think of it this way. Every new should have one matching delete. Thus, currentNode does not need to be deleted because it was never new'ed.

This works just fine, for example:

Code:

node *root = new node;
function(root);
delete node;

void function(node *root) {
    node *some = root;
    // ...
    // some is not deleted or freed
}

[edit] In the grand tradition of house demolishers: your code is doing the equivalent of making a photocopy of the bulldozers' contract. It doesn't warrant another bulldozer; it's just duplicating the same information. [/edit]