prototypes

[DevarajA]

If a function is visible everywhere, even out the file where it is
declared and defined, why should i write prototypes?
--
Devaraja (Xdevaraja87^gm ail^c0mX)
Linux Registerd User #338167
http://counter.li.org

[DevarajA]

DevarajA ha scritto:

If a function is visible everywhere, even out the file where it is
declared and defined, why should i write prototypes?

I've just read that they're used for type checking when calling external
functions. Is that true?

--
Devaraja (Xdevaraja87^gm ail^c0mX)
Linux Registerd User #338167
http://counter.li.org

[osmium]

"DevarajA" <[e-mail]> wrote in message
news:Om******** *************@n ews4.tin.it...

DevarajA ha scritto:

If a function is visible everywhere, even out the file where it is
declared and defined, why should i write prototypes?

I've just read that they're used for type checking when calling external
functions. Is that true?

The thing described by the OP (who,oddly enough, has the same nym as you) is
not an external function. He said it was *visible*. C does compiling in a
forward direction and it must know the argument types when it compiles. So
if you do the physical definition prior to the first usage you don't need a
prototype. This is sometimes called "Pascal style". The prototypes for
external functions are usually in a visible header file.

[DevarajA]

osmium ha scritto:

"DevarajA" <[e-mail]> wrote in message
news:Om******** *************@n ews4.tin.it...

DevarajA ha scritto:

If a function is visible everywhere, even out the file where it is
declared and defined, why should i write prototypes?

I've just read that they're used for type checking when calling external
functions. Is that true?

The thing described by the OP (who,oddly enough, has the same nym as you) is
not an external function. He said it was *visible*. C does compiling in a
forward direction and it must know the argument types when it compiles. So
if you do the physical definition prior to the first usage you don't need a
prototype. This is sometimes called "Pascal style". The prototypes for
external functions are usually in a visible header file.

so why this works and only gives "implicit declaration" warnings?

int main()
{
a(8,9);
b(9,9.5);
c(9.5,10);
return 0;
}
int a(int x, int y){return 0;}
int b(int x, double y){return 0;}
int c(double x, int y){return 0;}
--
Devaraja (Xdevaraja87^gm ail^c0mX)
Linux Registerd User #338167
http://counter.li.org

[osmium]

"DevarajA" writes:

so why this works and only gives "implicit declaration" warnings?

int main()
{
a(8,9);
b(9,9.5);
c(9.5,10);
return 0;
}
int a(int x, int y){return 0;}
int b(int x, double y){return 0;}
int c(double x, int y){return 0;}

There was a time when something called K&R C was a more or less de facto
standard. Before there was a real standard. It assumed that everything was
int. Your compiler is in a mode such that it accepts the old dialect.

[DevarajA]

osmium ha scritto:

"DevarajA" writes:

so why this works and only gives "implicit declaration" warnings?

int main()
{
a(8,9);
b(9,9.5);
c(9.5,10);
return 0;
}
int a(int x, int y){return 0;}
int b(int x, double y){return 0;}
int c(double x, int y){return 0;}

There was a time when something called K&R C was a more or less de facto
standard. Before there was a real standard. It assumed that everything was
int. Your compiler is in a mode such that it accepts the old dialect.

So for that old standard a call to a undeclared function f1 is an
implicit declaration (as int f1(...))?

--
Devaraja (Xdevaraja87^gm ail^c0mX)
Linux Registerd User #338167
http://counter.li.org

[John Bode]

DevarajA wrote:

If a function is visible everywhere, even out the file where it is
declared and defined, why should i write prototypes?
--
Devaraja (Xdevaraja87^gm ail^c0mX)
Linux Registerd User #338167
http://counter.li.org

You need to have a prototype declaration in scope if the function is
being called before it has been defined. If you have all your
functions in the same file, and you define each function before it is
used, you don't need a prototype declaration.

Example:

double foo(int x, float y)
{
...
}

char *bar(void)
{
...
double g = foo(1, 2.0);
}

int main(void)
{
char *msg = bar();
...
}

Since the functions are defined (using prototype syntax) before they
are called, the compiler is able to verify that the return types and
the number and types of arguments match between the definition and
call.

Now, suppose the order were reversed:

int main (void)
{
char *msg = bar();
...
}

char *bar(void)
{
double g = foo(1, 2.0);
...
}

double foo(int x, float y);
{
...
}
When the compiler sees the call to bar(), it has no prior definition or
declaration of bar in scope, so it assumes bar() returns int, and does
no parameter checking. In this case, the compiler should issue a
diagnostic since it thinks you're trying to assign an int value to a
char *. Similarly, when the compiler first sees the call to foo(), it
assumes that foo() returns int, does no checking on the parameters, and
applies the default type promotions (IIRC, without a definition or
declaration in scope, 2.0 will be passed as a double instead of a
float). Again, you'll get a warning about trying to assign an int to a
double.

[Eric Sosman]

osmium wrote:

"DevarajA" <[e-mail]> wrote in message
news:Om******** *************@n ews4.tin.it...

DevarajA ha scritto:

If a function is visible everywhere, even out the file where it is
declared and defined, why should i write prototypes?

I've just read that they're used for type checking when calling external
functions. Is that true?

The thing described by the OP (who,oddly enough, has the same nym as you) is
not an external function. He said it was *visible*. C does compiling in a
forward direction and it must know the argument types when it compiles. So
if you do the physical definition prior to the first usage you don't need a
prototype. This is sometimes called "Pascal style". The prototypes for
external functions are usually in a visible header file.

There's some evidence of confusion here, so to clear
the air: A prototype is the parenthesis-enclosed list of
types or type/argument pairs that appears in a function
declaration. It is possible to declare a function with
a prototype

double func(double, int, const char*);

or without a prototype

double func();

Equally, it is possible to define a function with a
prototype

double func(double x, int i, const char *s) {
return x + i * strlen(s);
}

or without a prototype

double func(x, i, s)
double x;
int i;
const char *s;
{
return x + i * strlen(s);
}

DevarajA and osmium seem to be saying "prototype" when
what they actually mean is "declaratio n." osmium's point
is that a function definition is also a declaration (though
the opposite is clearly not true), and is really not about
prototypes at all.

--
Er*********@sun .com

[Eric Sosman]

John Bode wrote:

DevarajA wrote:

If a function is visible everywhere, even out the file where it is
declared and defined, why should i write prototypes?
--
Devaraja (Xdevaraja87^gm ail^c0mX)
Linux Registerd User #338167
http://counter.li.org

You need to have a prototype declaration in scope if the function is
being called before it has been defined. [...]

No: You need a declaration, but the declaration is not
required to provide a prototype. (Under C90 rules, even
the declaration is sometimes optional.)

Prototypes are a Good Thing; I cannot think of a case
where a prototype-less declaration wouldn't be improved by
adding a prototype. However, the only time a prototype is
actually required is when the function has a variable-length
argument list. All fixed-length prototypes can be omitted,
if you've got masochistic tendencies and are willing to suffer
opprobrium from others who work with your awful code.

--
Er*********@sun .com

[John Bode]

Eric Sosman wrote:

John Bode wrote:

DevarajA wrote:

If a function is visible everywhere, even out the file where it is
declared and defined, why should i write prototypes?
--
Devaraja (Xdevaraja87^gm ail^c0mX)
Linux Registerd User #338167
http://counter.li.org

You need to have a prototype declaration in scope if the function is
being called before it has been defined. [...]

No: You need a declaration, but the declaration is not
required to provide a prototype. (Under C90 rules, even
the declaration is sometimes optional.)

Prototypes are a Good Thing; I cannot think of a case
where a prototype-less declaration wouldn't be improved by
adding a prototype. However, the only time a prototype is
actually required is when the function has a variable-length
argument list. All fixed-length prototypes can be omitted,
if you've got masochistic tendencies and are willing to suffer
opprobrium from others who work with your awful code.

--
Er*********@sun .com

You're right. That first sentence should be amended to, "you need to
have a declaration in scope (preferably using prototype syntax in favor
of the old K&R-style syntax) ..."