NULL pointer dereferencing - behaviour

[BigMan]

Does the C++ standard define what should happen in case of NULL pointer
dereferencing. If not, does it say that it is illegal?

Where, if so, does it say it?

[BigMan]

And what if I dereference a pointer to a structure like this:

SturctPtr->Member;

What should happen if StructPtr is NULL and Member is not first in the
structure, i.e. it is alligned at 4 bytes from the beginning?

[Andrea Sini]

BigMan wrote:

Does the C++ standard define what should happen in case of NULL pointer
dereferencing. If not, does it say that it is illegal?

I know that in C++ the use of NULL is almost deprecated.

Stroustrup suggests to prefer 0, because no object is allocated at the
address 0.

Moreover, I don't think that exists a standard behaviour about Null
pointer deferencing.

It's something that happens at run time and a C++ compiler has no
control on it (IMHO).

P.S:

Why on the Earth a person should try to dereference (with awareness) a
NULL pointer ???

Bye

Andrea

[Victor Bazarov]

BigMan wrote:

And what if I dereference a pointer to a structure like this:

SturctPtr->Member;

What should happen if StructPtr is NULL and Member is not first in the
structure, i.e. it is alligned at 4 bytes from the beginning?

The result of dereferencing a null pointer is _undefined_. IOW, anything
can happen and is allowed to happen AFA C++ is concerned. Most modern
operating systems will indicate some kind of exceptional situation and
abort the offending program. But that's not guaranteed.

V

[Noah Roberts]

BigMan wrote:

Does the C++ standard define what should happen in case of NULL pointer dereferencing.

Yes.

It says what happens is undefined.

[Chris Croughton]

On Tue, 15 Feb 2005 15:09:27 GMT, Andrea Sini <[e-mail] > wrote:

BigMan wrote:

Does the C++ standard define what should happen in case of NULL pointer
dereferencing. If not, does it say that it is illegal?
I know that in C++ the use of NULL is almost deprecated.

Stroustrup suggests to prefer 0, because no object is allocated at the
address 0.

He's wrong (if he actually suggests it for that reason). The constant
zero assigned or compared to a pointer is evaluated as a null pointer,
whatever value that has in that implementation (it might actually be all
bits set, or a 'trap' value). An implementation can put objects at an
address of zero if it likes.
Moreover, I don't think that exists a standard behaviour about Null
pointer deferencing.
It's explicitly undefined behaviour, and can cause demons to fly out of
your nose, or World War III, or an asteroid to hit your home town. It
may cause a trap (bus error, interrupt, signal, code dump or whatever)
but it may not (and will not on one of the most common CPU architectures
as well as on some systems under another common architecture).

(As for what happens when one dereferences a derived pointer, like a
structure member, that's even less defined if that's possible, because
many systems won't even trap it...)
It's something that happens at run time and a C++ compiler has no
control on it (IMHO).
Well, a compiler could issue code protecting every memory access...
Why on the Earth a person should try to dereference (with awareness) a
NULL pointer ???

Perhap the OP likes demons flying out of zir nose? I haven't tried it
myself, it might be a turn-on for some people (like banging heads
against a brick wall).

Chris C

[ajitho]

#include <stdio.h>

class MyClass {
public:
void A() {
if (this==NULL) printf("NULL Pointer\n");
}
};
void main() {
MyClass *ptr = 0;
ptr->A();
}

[Victor Bazarov]

Chris Croughton wrote:

On Tue, 15 Feb 2005 15:09:27 GMT, Andrea Sini <[e-mail] > wrote:

BigMan wrote:

Does the C++ standard define what should happen in case of NULL pointer
dereferencin g. If not, does it say that it is illegal?
I know that in C++ the use of NULL is almost deprecated.

Stroustrup suggests to prefer 0, because no object is allocated at the
address 0.

He's wrong (if he actually suggests it for that reason).

He actually suggests it for a different reason. 'NULL' is a simple macro
that in most implementations (all implementations I've seen) expands into
0. So, by using 'NULL' instead of '0' the programmer is fooling himself
into believing he's using a pointer while really it's just a damn integer
literal. Using '0' instead of a symbol [mis-]representing it is clearer.
The constant
zero assigned or compared to a pointer is evaluated as a null pointer,
whatever value that has in that implementation (it might actually be all
bits set, or a 'trap' value). An implementation can put objects at an
address of zero if it likes.

The introduction of a null pointer constant represented by a reserved word
("nullptr") will hopefully resolve all the confusion caused by "should I
use NULL or 0 for pointers", since it will make a clear distinction
between the two. The conversion will still exist (since the introduction
cannot break zillions of tons of code already written to use 0), but many
good things are going to come out of it. You can read more about it in
the document SC22/WG21/N1601 J16/04-0041.

[...]

V

[Victor Bazarov]

ajitho wrote:

#include <stdio.h>

class MyClass {
public:
void A() {
if (this==NULL) printf("NULL Pointer\n");
}
};
void main() {
MyClass *ptr = 0;
ptr->A();
}

What is your point? Do you not understand the word "undefined" ?
Your program has at least two reasons for undefined behaviour. The
first is declaring 'main' "void".

V

[ajitho]

#include <stdio.h>

class MyClass {
public:

void A(const MyClass &arg)
{
if (&arg == 0) {
printf("Null reference!\n");
}
}

};
void main() {
MyClass ptr;

ptr.A( *(MyClass *)0);
}