CODEWITHSUNDEEP
c++pointers
user1163392
user1163392

Reputation: 167

Null pointers in C++

I've got a couple of questions regarding pointers. First:

 ObjectType *p; 
 p->writeSomething();

Why is it possible to call a method on an object when the pointer hasn't been initialized? If I run that code I get the output from "writeSomething()" in my console window. Second:

ObjectType *p;
if(p==NULL) 
cout<<"Null pointer";//This is printed out
p = new ObjectType;
delete p;
if(p==NULL)
   cout<<"Null pointer";
else
   cout<<"Pointer is not null";//This is printed out

Why isn't the pointer null in the second if statement and how do I check if a pointer isn't pointing to any memory address? I'm also wondering if there is any way to check if some memory hasn't been released when a program is done executing. For example, if you forget to write 1 delete statement in the code.

Upvotes: 1

Views: 344

Answers (4)

Kerrek SB
Kerrek SB

Reputation: 477640

Your code does of course exhibit undefined behaviour, but here's an example of why it may appear possible to call a member function even if there is no object: If the member function doesn't refer to any member objects of the class, then it will never need to access any part of the memory which you haven't initialized. That means, your member function is essentially static.

As you know, member functions can be considered as normal, free functions which have an implicit instance object reference argument. For example, a simple class Foo defined like this,

struct Foo
{
    void bar() { std::cout << "Hello\n"; }
};

could be implemented as a single, free function:

void __Foo_bar(Foo * this)
{
    std::cout << "Hello\n";
}

Now when you say Foo * p; p->bar();, this amounts to a free function call __Foo_bar(p);. You end up passing an invalid pointer to the function, but since the function never makes use of the pointer, no harm is done.

On the other hand, if your class had a member object, like int Foo::n;, and if the member function was trying to access it, your implementation would try and access this->n, which would very likely cause an immediate problem since you'd actually be dereferencing an invalid pointer.

Upvotes: 3

David Heffernan
David Heffernan

Reputation: 613572

delete p;

deallocates memory, but it does not change the value of the address stored in p.

There is no method in standard C++ to detect that a pointer is referring to invalid memory. It is your responsibility not to de-reference an invalid pointer.

Your first example is undefined behaviour. One of the possible outcomes of undefined behaviour is that the program works the way you intended it to. Again, it is your responsibility not to write programs with undefined behaviour.

In your code, writeSomething() is probably a non-virtual member function that does not de-reference this which is why it happens to work for you, on your compiler. Most likely if you tried to refer to some member data fields then you would encounter a runtime error.

Upvotes: 2

Jay D
Jay D

Reputation: 3297

delete would call upon the destructor of ObjectType followed by de-allocation of memory but it doesn't explicitly makes your pointer NULL

That is something you have to do as a good programming practice.

Upvotes: 0

Luchian Grigore
Luchian Grigore

Reputation: 258678

The first code is undefined behavior, anything can happen, even appearing to work. It's probably working because the call is resolved statically, and you're not accessing any members of the class.

For the second snippet delete doesn't set the pointer to NULL, it just releases the memory. The pointer is now dangling, as it points to memory you no longer own.

Upvotes: 7

Related Questions