Default Arguments in C++ Functions

In C++, you can provide default values for function arguments. All default argument names of a function are bound when the function is declared. All functions have their types checked at declaration , and are evaluated at each point of call.

For example :

/**
 ** This example illustrates default function arguments
 **/

#include <iostream.h>
int a = 1;
int f(int a) {return a;}
int g(int x = f(a)) {return f(a);}

int h()
{
     a=2;
     {
            int a = 3;
            return g();
     }
}

main()
{
     cout << h() << endl;
}

This example prints 2 to standard output, because the a referred to in the declaration of g() is the one at file scope, which has the value 2 when g() is called. The value of a is determined after entry into function h() but before the call to g() is resolved.

A default argument can have any type.

A pointer to a function must have the same type as the function . Attempts to take the address of a function by reference without specifying the type of the function produce an error. The type of a function is not affected by arguments with default values.

The following example shows that the fact that a function has default arguments does not change its type . The default argument allows you to call a function without specifying all of the arguments, it does not allow you to create a pointer to the function that does not specify the types of all the arguments. Function f can be called without an explicit argument, but the pointer badpointer cannot be defined without specifying the type of the argument:

int f(int = 0);
void g()
{
   int a = f(1);                // ok
   int b = f();                 // ok, default argument used
}
int (*pointer)(int) = &f;       // ok, type of f() specified (int)
int (*badpointer)() = &f;       // error, badpointer and f have
                                // different types. badpointer must
                                // be initialized with a pointer to
                                // a function taking no arguments.

Calling Functions and Passing Arguments
Restrictions on C++ Default Arguments
Evaluating C++ Default Arguments