Deleting Pointers?

A) Say I have a pointer in my main, and I send that pointer to a function as an argument:

Code:

---

int main()
{
  Object *myPtr;
  someFunction(myPtr);
}

---

In that function:

Code:

---

void someFunction(Object *somePtr)
{
  somePtr = 0;
  delete somePtr;
}

---

Since it points to the same location in memory, does that delete the original object?

-----

B) How do I delete a pointer if it's a return type?

Code:

---

Object* someFunction()
{
  AnotherObject* myPtr2;
  return myPtr2;
}

---

Is there a way to get that memory back for myPtr2?

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;

      ---

Quote:

---

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! :)

Quote:

---

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?

Quote:

---

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).

Quote:

---

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)

Of course myPtr2 was created using new -- it's right there on the line above! The point being that myPtr2 and myPtr1 have the same value, so deleting one is the same as deleting the other. Assigning myPtr2 to be myPtr1 does not create another copy of your Object.

Edit: Or perhaps I should say that the Object that myPtr2 is pointing at was created using new.

As to your second question, you have that backwards -- you need to delete myPtr1 first, then set myPtr1 = 0 (so that you can check there's nothing there).

Quote:

---

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.

Quote:

---

-----

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

>> B2) it's a memory leak because the object is still in memory somewhere?
If you add that code to the previous code, then there is no memory leak (but the delete still does nothing):

Code:

---

Object* myPtr1 = new Object();

Object* myPtr2 = myPtr1;

delete myPtr2;

myPtr1 = 0; // good idea since previous memory pointed to is now invalid

delete myPtr1; // does not leak memory, but does nothing and should be removed

---

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.

Quote:

---

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.

Quote:

---

Originally Posted by Elysia

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.

---

Haha! Love the analogy!

Is it the same through function calls? Say you pass the address to a new function. And in that function, the pointer is deleted. When the program returns, is the house in the calling function also demolished?

Yes. There is only one house. If delete is called on that address, then the house is destroyed. It doesn't matter where the person/code is that makes the call to delete.

Agreed. Good analogy.

Quote:

---

Originally Posted by Daved

Yes. There is only one house. If delete is called on that address, then the house is destroyed. It doesn't matter where the person/code is that makes the call to delete.

---

Ok, so my program has a heap data structure.

I have a function that does some sorting of the nodes.

I have like Node* currentNode = Root; // Root given as function argument
And I do some operations with that.

What is the proper way to return the memory from those pointers I'm using to sort things? I shouldn't delte them, because that would delete the actual nodes, right? Do I just not do anything with them at the end of the sorting function?

Quote:

---

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]

Quote:

---

Originally Posted by dwks

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. ;)

---

Ahhhh ok. I get it! Good way of putting it.

Ok, now what happens if I don't do anything with that pointer.

And then back in main, I call delete. Are those pointers within the function still pointing to the object? So it will cause a seg fault?

Remember: pointers are the addresses.
Duplicating the address will do nothing to the house. As soon as you call delete on one pointer, it will demolish the house it points to, so all pointers will now contain an address to a demolished house. The pointers are still valid, but the address is not.

If you demolish the house first and then try to use it is a way, you will (likely) get a seg fault.
Similarly, just defining (creating) pointers will not create a house. The pointers will contain a "random" address, which may or may not, contain the address of a real house (therefore you may call it undefined).
It is the operator new (keyword) that actually creates a house. So long as the house exists, you can copy the address indefinetly and use it indefinetely, as long as you want, until you call delete, upon which time the house is demolished and the address is invalid.

>> And then back in main, I call delete. Are those pointers within the function still pointing to the object?
If you're back in main, then the function is done. The execution flow of a program follows a specific path. If you call a function and it uses a pointer that points to an object that has been deleted, you will have problems.

There is a concept called ownership of a resource. When you use new to allocate memory, you are creating a resource. Something has to own that resource. Whatever owns that resource is responsible for cleaning it up (in this case by deleting it). Your task as a C++ programmer is to identify which part of the code owns the resource, and make sure that no other code will attempt to use it after the owner has destroyed it.

Of course, in C++, there are many tools available that make managing resources easier. For example, the vector class helps manage a dynamic array. Smart pointers like shared_ptr or auto_ptr help manage raw pointers like the ones you're using. There are container classes like set that do the dirty work and provide most of what you need in a data structure. You should strive to use those tools to make a better problem that doesn't have as many errors when it comes to managing resources. (That doesn't mean it's not a good idea to learn how to do it yourself, though, just don't do it yourself in your real programs if you don't have to.)

Alrighty, I've learned quite a lot about pointers today! Thanks guys, awesome analogies hehe :) So I changed a bunch of stuff around in my code, and it worked for everything except for the last pointers when I'm about to quit the program.

I have 5 pointers I need to delete. Two of them delete fine ("t" and "nr").

Three of them cause seg faults ("circ", "ptr2set" and "ptr2elem").

"circ" and "ptr2set" have "Bad Ptr" values when I debug

Screenshot of Visual Studio Debugging: http://img526.imageshack.us/img526/9804/badptrqt2.png

A) Is "Bad Ptr" a double deletion error?

-----

And the 5th pointer, "ptr2elem", causes a seg fault as well, but doesn't have the value "Bad Ptr" when debugging. Instead, this happens: http://img296.imageshack.us/img296/3...tr2elemvx1.png

B) What the heck does that mean?

Unfortunately, this is a really bad way of solving this issue. You can't rely on the debugger to tell you what to delete and what not to. You have to design and understand the logic of your code to figure out what to delete. Every pointer address returned by new should be deleted once and only once. If you make copies of that address then you need to keep track of the copies and make sure only one is the official copy that gets deleted.

If you have trouble doing this, then you should consider using the tools C++ gives you that manage this for you.