class object
{
public:
void check()
{
std::cout<<"I am doing ok..."<<std::endl;
}
};
int main()
{
object *p = new object;
p->check();
delete p;
p->check();
delete p;
p->check();
}
EDIT: Gurus, i am confused by many of the statements "it may crash or may not".. why isnt there a standard to say, this how we deal with a block of memory that is deleted using 'delete operator'..? Any inputs ?
Because the function is not doing anything with the object's member data or the this pointer.
It's like calling a function
void check(object *self)
{
std::cout<<"I am doing ok..."<<std::endl;
}
with an invalid pointer as the self argument.
There is a double delete though, which can crash in some environments.
I think it depends on the environment (platform/compiler)...
This at least gives unexpected behaviour.
I think you are lucky that it doesn't crash in your case ;-)
Because what it actually looks like after the compiler has had its way, is something like this:
object::check( object* this )
{
// do stuff without using this
}
int main()
{
object *p = new object;
object::check( p );
delete p;
object::check( p );
delete p;
object::check( p );
}
Since you're not touching "this", you don't actually access any bad memory.
Although, deleting p twice should be able to cause a crash:
http://www.parashift.com/c++-faq-lite/freestore-mgmt.html#faq-16.2
Delete only deallocates memory and makes it available back to the heap.
The value of the pointer is undefined after delete has been called, so it may crash it may not.
A programming tip I use to reduce programming errors is to after a delete, set the pointer to NULL. In this way, you know you are not accidently using a pointer after it's been deleted.
Even if the method call was using the this pointer it would not be guaranteed to crash. The pointer p when deleted is not being zeroed so is still pointing to the same address in memory. Depending on the implementation of new/delete and the heap manager this memory might not even be resused so the use of p may still continue to work even though the memory has been released.
To add a little to what others have said, try using a member variable of your class inside the check() method and then see what happens.
Function calling in case of classes is similar to normal function calling except for one little difference. The arguments are pushed on stack in both cases but in case of a function call of an object, 'this' is pushed on to the stack as the first argument. This 'this' is used inside function to access the member variables. Since you are not accessing any member variables, it is working. And yes, it can work even if you access member variables but you will get unexpected behavior because compiler is free to use the memory that was allocated to 'p'. As soon as compiler will utilize that memory, you will start getting crashes. For example, if you declare further variables after deleting before reusing 'p', it might crash.
Edit: Furthermore, if your method is not accessing any member variable, then it is a definite candidate to be a static method.
You can do the same with nil pointers, just as long as you never access the state of the class instance:
class object
{
public:
void check()
{
std::cout<<"I am doing ok..."<<std::endl;
}
};
int main()
{
object *p = 0;
p->check();
}
It's even funnier than that. This compiles & runs nicely:
#include <iostream>
using namespace std;
class object {
public:
void check() {
cout << "I am doing ok..." << endl;
}
};
int main() {
object *p = (object*)0;
p->check();
return 0;
}
On to the shell:
$ g++ -o t t.cc $ ./t I am doing ok... $
:) You don't actually have to have an object to call this method! cheers, h
1) Depends on compiler, on Mac OS with gcc 4.0.1:
g++ -Wall -g -c main.cpp -o main.o
g++ -o x main.o
./x
I am doing ok ...
I am doing ok ...
x(5857) malloc: *** error for object 0x100150: double free
*** set a breakpoint in malloc_error_break to debug
I am doing ok ...
Double free is causing problems.
2) Generally deleting pointer that has already been deleted is not defined, you should always set pointer to 0 after deleting, calling delete on pointer with value 0 is allowed.
3) The reason it can still print the string is that the pointer still points to memory that was now freed, but I would assume that only the pointer is reclaimed e.g. returned to free pool for reuse, the memory is not overwritten or nulled so if you dereference the pointer you still get the original values, unless the memory is reused in the meantime.
delete does not set p to null so it still points to the memory location. It depends on implementation of new/delete but usually delete only marks that part of memory as available for any new allocations.
Its like when you delete a file off your hardrive. The file system simply marks that area as available. The file data exists and can still be recovered as long as you don't do new writes.