Default arguments and prototypes

If I feed this to g++:
--------
int foo(int i=42);

int foo(int i=42)
{
return i;
}
--------
It says (with -W -Wall -ansi -pedantic):
--------
foo.C: In function `int foo(int = 42)':
foo.C:4: warning: default argument given for parameter 1 of `int
foo(int = 42)' foo.C:1: warning: after previous specification in `int
foo(int = 42)' --------

Does this warning indicate any actual problems, or is it just pointing
out that with the default argument given in the prototype it's not
needed in the function definition as well?
AFAIK it should not be there at all.
Are there any good reasons not to use this:
--------
int foo(int i=42);

int foo(int i)
{
return i;
}
--------
instead?

If I feed this to g++:
--------
int foo(int i=42);

int foo(int i=42)
Drop the default argument value from the line above
{
return i;
}
--------
It says (with -W -Wall -ansi -pedantic):
--------
foo.C: In function `int foo(int = 42)':
foo.C:4: warning: default argument given for parameter 1 of `int foo(int = 42)' foo.C:1: warning: after previous specification in `int foo(int = 42)'
--------

Does this warning indicate any actual problems, or is it just pointing
out that with the default argument given in the prototype it's not needed
in the function definition as well? (I can see how this would lead to
a minor maintenance problem with the values getting out of sync.)
According to the Standard, once a default argument value has been
given, no other default argument is allowed to be specified.
Are there any good reasons not to use this:
--------
int foo(int i=42);

int foo(int i)
{
return i;
}
--------
instead?
I guess I don't understand the question. What do you mean "reasons
not to use this"? "This" is the only way the code is going to be
accepted. A good enough reason for you?
(And, while I've got your attention, am I correct in thinking that if
only the prototype is given in another translation unit, that prototype
is required to specify the correct default value of the argument?)

No, you're not. Every declaration in its own translation unit is
allowed to have its own default argument value.

According to the Standard, once a default argument value has been
given, no other default argument is allowed to be specified.

<snip>

(And, while I've got your attention, am I correct in thinking that if
only the prototype is given in another translation unit, that prototype
is required to specify the correct default value of the argument?)

No, you're not. Every declaration in its own translation unit is
allowed to have its own default argument value.

Victor Bazarov wrote:

According to the Standard, once a default argument value has been
given, no other default argument is allowed to be specified.

<snip>

(And, while I've got your attention, am I correct in thinking that if
only the prototype is given in another translation unit, that prototype
is required to specify the correct default value of the argument?)

No, you're not. Every declaration in its own translation unit is
allowed to have its own default argument value.

OK, I have a question along these same lines (since we're on the topic).
Is the following allowed?

void f(int, int=3);
void f(int=2, int); // add another default?

I was reading about this in the standard yesterday, and couldn't decide
whether this would be allowed. I know this is not:

void f(int, int=3);
void f(int=2, int=3); // ERROR: can't give a new default (even if
// the value is the same) in the same scope

Nor is this:

void f(int, int=3);

{
void f(int=2, int); // ERROR: Does not inherit default from
// enclosing scope, so this violates the
// rule than only trailing args have
// default values.
}

Right?