i have quick question (i think quick). I have to check if pointer is NULL after delete data pointed by pointer. In my case i have data stored in fl->first and i want to clear this data. After clear by delete fl->first i have to check if fl->first pointer is NULL. I read a lot of posts that
delete fl->first;
fl->first = NULL;
is not good idea. And is there better way or in this case it is okey?
You should not use the NULL macro in C++. Using nullptr literal is preferable instead. This is because the macro is ambiguous in some cases which may lead to confusion.
Besides that, you should typically avoid owning bare pointers, and thus deleting anything directly is usually not a good idea.
fl->first = nullptr; is C++ way of pointing to address of 0 in most cases (it does not mean that it is always 0). Why because in C you have void * in C++ you do not. You better read this.
That is as simple as it gets.
Longer answer is in void * you can allocate memory for 1000 chars, but you can read and write ints into them. To avoid this and for compilers to be more type safe C++ is going away from NULL and void *.
Yes this is a good idea, the reason being that it avoids crashes if you accidentally try to delete the same object again.
Example:
Foo* foo = new Foo(); // Create a new object
delete foo; // Deletes the object
delete foo; // Tries to delete an already deleted object and will therefor crash the program
Fix:
Foo* foo = new Foo(); // Create a new object
delete foo; // Deletes the object
foo = 0; // Sets the pointer to 0 (nullptr)
delete foo; // Deletes nothing, the program will NOT crash
delete foo;. And to refactor the program in such way that it becomes impossible to do so accidentally.
foo = 0 and foo = NULL (and foo = nullptr) are all identical if foo is a pointer. 0, NULL and nullptr are all null pointer constants. The thing that was being pointed out to you is that assigning the null pointer constant 0 to a pointer doesn't necessarily set all of its bits to 0. The actual bit pattern of a null pointer can vary by platform.