implicit declaration in C++ considered harmful

implicit declaration in C++ considered harmful

[Joe Buck]

I'd like to nuke the implicit declaration of functions in C++.  This
thoroughly broken feature cannot be turned off.

Yes, you get a warning, and you can make warnings errors, but the problem
is that if a user forgets to declare a function, or mistypes it, cascades
of dozens of errors can result, because g++ declares it as int foo(...),
then objects to all class objects passed to this function, then objects
to use of the result in a context where ints aren't allowed, etc.
Or else the file compiles normally, and errors aren't noticed until link
time.

Now, in the early days of C++ when we were all basically C programmers,
this hangover from K&R C may have been desirable.  But the time is overdue
to kill this sucker; these days, chances are good that most functions
I write are going to get a class object passed to them, so the default
declaration just can't be right.

First, it should be an error, not a warning.  Second, the compiler should
insert an error node, not a function returning integer, so that we don't
get a cascade of errors.

Is there anyone who really wants the existing behavior?

Joe

implicit declaration in C++ considered harmful

[Gabriel Dos Reis]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 530 bytes --]

>>>>> «Joe», Joe Buck <jbuck@synopsys.com> wrote:

Joe> First, it should be an error, not a warning.  Second, the compiler should
Joe> insert an error node, not a function returning integer, so that we don't
Joe> get a cascade of errors.

100% agreed.

Joe> Is there anyone who really wants the existing behavior?

I think EGCS should be standard conforming and flags implicit
declaration as an error not a warning.

-- Gaby
"One reason that life is complex is that it has a 
real part and imaginary part." -- Andrew Koenig

Re: implicit declaration in C++ considered harmful

[Martin von Loewis]

> The C and C++ standards don't distinguish errors and warnings,
> though I say this with somewhat less than full confidence because
> I'm not as familiar with the C++ draft as with the C standard.
>
> Both types of messages qualify as ``diagnostics''.  

C++ is the same, here.

> A C++ compiler could treat undeclared functions as being implicitly
> declared int (...) provided that it emits a diagnostic.

Sure it could. I think Joe made his point: even though g++ is
currently compliant (in this respect), producing an error would be
also compliant.

The real question is which one is more desirable.

> A conforming C compiler is allowed to translate even a
> *syntactically* incorrect program, provided that it diagnoses the
> syntax violation!

Right. This doesn't mean the compiler *has* to produce a program from
incorrect source :-) It may provide some non-standard extensions,
whose usage it needs to diagnose. Users of these extensions would
expect that they get a working program.

The question is whether assuming implicit declarations for global
functions is a useful extension. I agree with Joe that it isn't.

Regards,
Martin

RE: implicit declaration in C++ considered harmful

[Kaz Kylheku]

On Wednesday, April 08, 1998 7:31 AM, Gabriel Dos Reis 
[SMTP:Gabriel.Dos-Reis@dptmaths.ens-cachan.fr] wrote:

> I think EGCS should be standard conforming and flags implicit
> declaration as an error not a warning.

The C and C++ standards don't distinguish errors and warnings,
though I say this with somewhat less than full confidence because
I'm not as familiar with the C++ draft as with the C standard.

Both types of messages qualify as ``diagnostics''.  A C++
compiler could treat undeclared functions as being implicitly declared
int (...) provided that it emits a diagnostic.

A conforming C compiler is allowed to translate even a
*syntactically* incorrect program, provided that it diagnoses
the syntax violation!

I believe I have seen compilers that produce
an a.out executable from an empty translation unit even
after diagnosing the error!

Another good example is compilers which allow incompatible
pointer assignments to pass by with a mere warning.
This is a constraint violation that requires a diagnostic; it
is as serious as a syntax error. The warning message
serves as an adequate diagnostic, however.

RE: implicit declaration in C++ considered harmful

[Joe Buck]

> > I think EGCS should be standard conforming and flags implicit
> > declaration as an error not a warning.
> 
> The C and C++ standards don't distinguish errors and warnings,
> though I say this with somewhat less than full confidence because
> I'm not as familiar with the C++ draft as with the C standard.

Yes, we technically comply, but nevertheless the current behavior
is not desirable.