Can I reuse variables or objects that I delete? - c++

Question

I've been trying to figure this out but can't quite get my head round it.
Say I declare an object in a header file such as:
#ifndef SOMECLASS_H
#define SOMECLASS_H
#include "otherclass.h"
class SomeClass
{
public:
SomeClass();
OtherClass *obj;
};
#endif // SOMECLASS_H
Can I do the following in my code?
obj = new OtherClass();
//Do something
delete obj;
obj = new OtherClass();
//Do something else
delete obj;
Or would I have to create a new obj?
I can't really think of a reason why I might need to do this but I'd like to know if it would work and also whether or not it would be a good idea (I know it's best to create objects on the stack generally but for the sake of argument let's say in this case it isn't an option).

Answer 1

I think you need to adjust your mental model of what's happening. Let's look at a simpler case where we don't have the SomeClass class:
int main() {
OtherClass *obj = new OtherClass();
delete obj;
obj = new OtherClass();
delete obj;
}
The first line is this function is a declaration. This declaration introduces an object called obj whose type is OtherClass*. The important thing here is that obj is just a pointer. It's not an OtherClass object. It just holds the address of one. So when you talk about the object obj, you are talking about the pointer.
This declaration has an initialiser which is = new OtherClass(). The expression new OtherClass() also introduces an object, but this time it is not named. This object has type OtherClass. The expression returns a pointer to that OtherClass object which you are using to initialise obj. So now the obj pointer object is pointing at the OtherClass object.
The memory model for this looks something like this:
obj
+-------------+ +------------+
| OtherClass* |----->| OtherClass |
+-------------+ +------------+
Now, you can use an object during its lifetime. The lifetime of obj is the scope of the function we declared it in. At the end of the function, obj goes out of scope and is destroyed. That is, the pointer is destroyed. The lifetime of the OtherClass object lasts up until we use delete on a pointer to it. The delete only destroys the OtherClass object and not the pointer. So after the first delete, we have this:
obj
+-------------+
| OtherClass* |----->
+-------------+
The pointer still exists. It's still pointing to the same place even, but the object that was there is now gone.
At this point, we can't attempt to use the OtherClass object, since it doesn't exist any more. However, we can certainly reuse the pointer object obj. When we do obj = new OtherClass() (which is an expression, not a declaration), we create a new OtherClass object and set obj to point at it. We're back to this situation:
obj
+-------------+ +------------+
| OtherClass* |----->| OtherClass |
+-------------+ +------------+
And then we delete it again.
The only difference between this example and your example is that obj is a member of SomeClass. Each object of type SomeClass will contain within it an OtherClass* pointer called obj. The lifetime of obj now is whatever the lifetime of the SomeClass object is. As long as that object is still alive, you can use obj in whatever way you like. Of course, if you delete the object it is pointing at, you cannot use that object.

Answer 2

Your code is ok.
If you want you can reuse your pointer any time you want.
obj = new OtherClass();
delete obj;
obj = new OtherClass();
remeber that when you call delete you call OtherClass destructor.
it is good practice, but not required, put pointer to zero after delete.
obj = 0;
This because, if after delete pointer you want to test, for instance
if(!obj) {
...
}
it is said that !obj == true.

Answer 3

Your code is fine, but in C++11 consider using unique_ptr to avoid having to call "delete" manually. Eg:
std::unique_ptr<OtherClass> obj(new OtherClass());
//Do something
obj.reset(new OtherClass()); //this deletes the previous object
//Do something else. The object will be deleted when obj goes out of scope.
Also you might want to consider changing your title to something like, "Can I reassign a pointer after deleting the object it points to?"

Answer 4

Yes it would work. When you do the second
obj = new OtherClass();
the obj points to deleted memory, but you set it to new value. There is nothing wrong with it.

Answer 5

Your code is fine.
Depending on how OtherClass works, you may consider doing:
obj = new OtherClass();
//Do something
// then do something else
delete obj;
But this is not always feasible. Should this not be applicable in your case, what you are currently doing is OK.
I'd just do obj = NULL; after the second delete. Just in case I need to test this pointer's value somewhere else, to determine whether it is in use or not.

Answer 6

To sum up : you can't use an instance of a class that has been deleted, but you can reuse the variable pointer which was used to store the address of the instance.
That is to say, you CANNOT do the following (from your code sample) :
obj = new OtherClass();
delete obj;
obj->objMethod(); // dereferencing a now invalid pointer => dangerous.
But you can do what you wrote in your question :
obj = new OtherClass();
//Do something
delete obj;
obj = new OtherClass();
//Do something else
delete obj;
Actually, the last sample of code is as valid as the following (with a simple int) :
int i = 42;
// Do something
i = 15;
// Do something