Hi Everyone,

I just heard from a friend of mine that there are few c compilers that
give an error when pointers are not initialised to NULL. Is it correct?
and if so, is there any standard for that?

Thanks in advance...

joe wright

Incorrect. There is no requirement in the Standard that any pointer be
initialized to NULL by the programmer. If the Standard wants a new
pointer to be NULL, the compiler does it. Static pointers at file scope
for example.

--
Joe Wright
"Everything should be made as simple as possible, but not simpler."
--- Albert Einstein ---

barry schwarz

Did you really mean error or is it actually just a warning.

Unfortunately, the standard does not prohibit diagnostics for
non-erroneous code. The standard also does not distinguish between
informational messages, warning messages, error messages, etc.
Consequently, in addition to the required diagnostics (e.g.,
constraint violations), the compiler writer is allowed to add any and
as many additional ones as he wants. It becomes a quality of
implementation issue.

The standard does require the compiler to accept a correct program
even if it issued optional diagnostics.

Some compilers use this flexibility intelligently, such as checking
the types of printf arguments against the conversion specifiers and
reporting mismatches. Others, in my opinion, go overboard (as in the
original post) and apparently do so inconsistently (why not flag other
uninitialized objects besides pointers).


Remove del for email

santosh

Any self-respecting compiler *shouldn't* emit an error for an
uinitialised pointer. I don't think the standard prohibits issuing a
diagnostic, (which would be more useful than an error), though. However
a compiler is bound to compile a correct translation unit.

cbfalconer

See below for standards (C99). Another option is N1124, but that
is not available in text form. There is no reason to initialize
pointers to NULL. There are many reasons to not derefernce
unitialized and invalid pointers, or NULL pointers.

--
Some useful references about C:
<http://www.ungerhu.com/jxh/clc.welcome.txt>
<http://www.eskimo.com/~scs/C-faq/top.html>
<http://benpfaff.org/writings/clc/off-topic.html>
<http://anubis.dkuug.dk/jtc1/sc22/wg14/www/docs/n869/> (C99)
<http://www.dinkumware.com/refxc.html> (C-library}
<http://gcc.gnu.org/onlinedocs/> (GNU docs)
<http://clc-wiki.net> (C-info)

keith thompson

sam_cit@yahoo.co.in writes:


In what context, and what exactly do you mean by "give an error"?

Pointer objects can be initialized to NULL, initialized to some other
value, or uninitialized. I don't think there's any context in which a
compiler is required to issue a diagnostic for an uninitialized or
null pointer. A decent compiler might issue a non-fatal warning on an
attempt to *use* a null or uninitialized pointer.

Show us an example, and we can tell you (a) what a compiler is
required to do, and (b) what a compiler is allowed to do.

--
Keith Thompson (The_Other_Keith) kst-u@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

richard heathfield

CBFalconer said:


<cough> I beg to differ. I can see why you might find reasons not to
initialise, but to say there is *no* reason to initialise is a bit strong, isn't it?

And that's a great reason for initialising pointers to NULL if you have no
better value for them - so that you can find out whether you can legally
dereference them by inspecting their value.

--
Richard Heathfield
"Usenet is a strange place" - dmr 29/7/1999
http://www.cpax.org.uk
email: rjh at the above domain, - www.

harald van dijk¶»žuü`™¨¥r‰

Agreed (although I assume this is merely poor choice of wording on CBFalconer's part), but...

....it's only in rare situations that you'll really need this.
Statically allocated variables are implicitly initialised to zero, for
auto variables it is almost always possible to not use them until
you've set them to a valid (and non-null) value, and it is impossible
to initialise dynamically allocated memory except by use of the
calloc() function, which is not guaranteed to work as one might expect
for pointers in the first place.

Initialising pointers to NULL can occasionally be good style, though.

richard heathfield

Harald van D?k said:


<snip>

Yes, but for me they are the exception rather than the rule.


Sure, but what's to stop Joe Maintainer from slipping in a deref by mistake,
halfway between declaration and first assignment? I'd rather make his
debugging job a bit easier by giving him a null pointer to detect.
<snip>

--
Richard Heathfield
"Usenet is a strange place" - dmr 29/7/1999
http://www.cpax.org.uk
email: rjh at the above domain, - www.

ian collins

And his compiler or lint's job a bit harder?

--
Ian Collins.