Pointers Question.....Null Pointers!!!!

My question is after you delete a pointer and then set it to null.....Can you assing a value to this pointer after you've set it to null?

After you delete a pointer, you cannot assign any value to it. If you meant create it using new, then yes you can reassign its value. Pointers can be reassigned while references cannot.

After you delete a pointer it's gone, you can't use it anymore. However, if you intend to use it again then you can set it to NULL when you've finished with it's original value so that you don't accidentally change that value and then set it to the new value when you get to that point in your program.

As a matter of good practice you should set all pointers to NULL when you create them unless you immediately set their value. And when you're done using them but don't want to destroy them completely you set them to NULL for safety and debugging reasons.

int * ptr;

ptr doesn't point to any spot in memory in particular yet, but rather is pointing to some random spot in memory. You could to this:

cout << &ptr << endl;

to see what address ptr is found at. But if you try this right now:

cout << *ptr << endl;

you never know what is going to happen. To fix this you need to point ptr at some spot in memory before you try to change it's value or do something with it besides using it's own address. This is one way to do that.

int num = 8;

ptr = &num;

ptr is now pointing to the spot in memory that was assigned to the variable num, it is no longer random. Now you can do this:

cout << *ptr << endl;

and know what to expect. If you want to point ptr someplace but not at some thing then you can do this:

ptr = NULL;

ptr is still real but it is pointing to a very special place in memory that doesn't represent anything. If you do this:

cout << &ptr << endl;

you will see that ptr is still at the same spot in memory. But if you do this:

cout << *ptr << endl;

you should get an error message because NULL is not a value, just a place.

You can also assign a spot in memory to ptr by using the new operator:

ptr = new int;

If you do this now:

cout << &ptr << endl;

you should still get the same result as above. If you try:

cout << *ptr << endl;

right now you should get an error or crash your program if you are lucky, because even though you have assigned a spot in memory to ptr, the spot in memory still doesn't have a value. Now the only way you can reach the spot in memory pointed to by ptr is to use ptr itself. Therefore you need to do something like this:

*ptr = 221;

and then you can do this;

cout << *ptr <<endl;

So far pretty basic pointer schtuff. Now let's say you don't need the memory assigned to ptr anymore so you want to delete it. No problem, do this:

delete ptr;

UNFORTUNATELY the above line doesn't delete ptr itself, it deletes the memory ptr points to. You can still do this:

cout << &ptr << endl;

and it should still be the same as it was every other time. But now ptr doesn't point to any memory and is therefore pointing someplace random again. So you can fix that by doing something like:

ptr = NULL;

or whatever. Remember the pointer itself is not deleted by delete, the memory the pointer points to is what is deleted. The pointer remains and can be used for any valid purpose after the delete statement.

Oh dear CeeCee, now I have to change my quote :p

I didn't really read this post that much, so if what I say has already been said sorry. If by deleting a pointer you mean freeing the memory that it points to then yes, you can reassign the pointer. You can reassign the pointer even if you don't "delete" it first, though this is a good way to create a memory leak. You must know though that you are not actually deleting the pointer, you are freeing the memory that it points to. One problem that I see with learning C++ before one learns C is that most C++ books don't explain what a pointer is and how it is different from an array or reference variable for that matter. That is how little confusions like this occur. Anyways C++ isn't really my thing, but I know a little, hope this helped...

Quote:

---

You could to this:

cout << &ptr << endl;

to see what address ptr is found at. But if you try this right now:

cout << *ptr << endl;

you never know what is going to happen

---

Assigning a pointer to an unknown chunk of memory is a good way to get a random value, especially in this case, where you'd get a random number without having to use formal functions.