Evaluation of default arguments (C++ only)
When a function defined with default arguments is called
with trailing arguments missing, the default expressions are evaluated.
For example:
void f(int a, int b = 2, int c = 3); // declaration
// ...
int a = 1;
f(a); // same as call f(a,2,3)
f(a,10); // same as call f(a,10,3)
f(a,10,20); // no default arguments
Default arguments are checked against the function declaration
and evaluated when the function is called. The order of evaluation
of default arguments is undefined. Default argument expressions cannot
use other parameters of the function. For example:
int f(int q = 3, int r = q); // error
The argument r cannot be initialized
with the value of the argument q because the value
of q may not be known when it is assigned to r.
If the above function declaration is rewritten:
int q=5;
int f(int q = 3, int r = q); // error
The value of r in the function declaration
still produces an error because the variable q defined
outside of the function is hidden by the argument q declared
for the function. Similarly:
typedef double D;
int f(int D, int z = D(5.3) ); // error
Here the type D is interpreted within the function declaration as the name of an integer. The type D is hidden by the argument D. The cast D(5.3) is therefore not interpreted as a cast because D is the name of the argument not a type.
In the following example, the nonstatic member a cannot
be used as an initializer because a does not exist
until an object of class X is constructed. You can
use the static member b as an initializer because b is
created independently of any objects of class X.
You can declare the member b after its use as a default
argument because the default values are not analyzed until after the
final bracket } of the class declaration.
class X
{
int a;
f(int z = a) ; // error
g(int z = b) ; // valid
static int b;
};