Function prototypes

[Steph Barklay]

Hi, I'm currently taking a data structures course in C, and my teacher
said that function prototypes are not allowed in any of our code. He
also said that no professional programmers use function prototypes. This
kind of bugged me, because from other people's code that I've seen in
the past, almost all of them use function prototypes. The following also
bugged me. Let's say you have a file called main.c with only the main
function, and includes hello.h, to use functions within hello.c. So
hello.h should contain prototypes for the functions in hello.c, so when
main.c is compiled, there won't be any warnings. If there aren't any
prototypes in the header file, my compiler would assume the function
called with main() is extern and returns an int. I tried to explain this
to my teacher, but the answer he gave me is that I should just put the
whole function within the header file and not have any other *.c files.
I haven't seen anyone put whole functions within header files before. Am
I wrong about this or is my teacher wrong? Thank you.

[Kenneth Brody]

Flash Gordon wrote:

>
Kenneth Brody wrote, On 27/08/07 18:16:

Keith Thompson wrote:

CBFalconer <cb********@yah oo.comwrites:

[...]

Some of them might not be all that ignorant. For example, some of
them just might post to comp.lang.c to find out what the instructor
really meant.

Sure, but what are the odds of that happening?

No idea, but it does happen because this thread was as a result of one
of the students posting here asking about it!

I guess I did need those smileys afterall. :-) :-)

--
+-------------------------+--------------------+-----------------------+
| Kenneth J. Brody | www.hvcomputer.com | #include |
| kenbrody/at\spamcop.net | www.fptech.com | <std_disclaimer .h|
+-------------------------+--------------------+-----------------------+
Don't e-mail me at: <mailto:Th***** ********@gmail. com>

[David Thompson]

On Fri, 24 Aug 2007 08:22:22 -0400, Eric Sosman
<es*****@ieee-dot-org.invalidwrot e:

Army1987 wrote:

On Fri, 24 Aug 2007 01:23:37 +0000, Richard Heathfield wrote:

>3. All constants must be in uppercase

return 0;

Alas, the constant in the `return' statement is not
in upper case. Suggested fix:

typedef { TRUE, FALSE } Boolean;
...
return TRUE;

s/typedef/typedef enum/

;-)

Ditto.

(Disclaimer: I didn't invent the `typedef', but ran
across it years ago in somebody else's code. It made for
an interesting debugging session ...)

At least enumeratees are usually IN debug symbols. Macros, the other
popular way of doing this, (too) often aren't. Although, of course,
they can be as far as the Standard, and thus clc, cares.

Now if you have enum { TRUE, FALSE } in some source files -- either
directly, or by #include'ing one header -- and enum { FALSE, TRUE } in
some other sources -- perhaps from a different header, perhaps even a
header with the same (file)name but a different place in the directory
(perhaps network) hierarchy -- then you're in truly evil territory.

- formerly david.thompson1 || achar(64) || worldnet.att.ne t

[David Thompson]

On Thu, 23 Aug 2007 20:04:25 -0400, pete <pf*****@mindsp ring.com>
wrote:
<snip>

I was granting that he meant prototypes in source code.

(I think it's established later he(?) meant forward declarations.)

But if you take him literally to just mean
making use of prototypes in code, then yes,
I don't think you can write a program for a modern C implementation,
that has any output, without using prototypes.

putchar and puts, along with getchar and <ALARM! DON'T USE>gets, can
be correctly (enough) declared without protototypes and without the
type FILE (which officially you can't use without #include'ing
<stdio.hand thereby getting prototype declarations).

It's certainly more convenient to have *printf, but everything printf
or fprintf(stdout do _can_ be done "manually" with putchar.

It's more powerful to have fopen/fclose/etc., but not strictly
necessary to get some output.

- formerly david.thompson1 || achar(64) || worldnet.att.ne t

[David Thompson]

On Thu, 23 Aug 2007 14:28:14 -0700, "osmium" <r1********@com cast.net>
wrote:

"Keith Thompson" writes:

I see no word games here. The word "prototype" has a very specific
meaning, and it includes both standalone function declarations:
void func(int);
and full function definitions:
void func(int arg) { /* ... */ }

<snip>

Do you have some reason to assume that the original poster was using
the term in the same narrow sense in which you were using it?

Of course I have such a reason. The instructor's programs wouldn't work
otherwise, all he could do is write functions that returned an int or
returned nothing. I have already agreed the instructor shouldn't have said
what he said. What do you want, blood?

That's not a valid reason. The nonprototype aka oldstyle aka K&R1
syntax does allow you to declare any supported return type for a
function; it is only the _parameter_ types that are omitted, or for an
oldstyle definition serving as a declaration discarded.

I agree from the later full quote that the instructor _meant_ the
prohibition of "prototypes " to mean forward declarations, and thereby
to require bottom-up* layout. But that is in fact not the correct
meaning of prototype, and the correct meaning is important.

* often associated with Pascal although it is not actually required
there, and is permitted and encouraged in several other languages.

- formerly david.thompson1 || achar(64) || worldnet.att.ne t