Function Overloading

C++ compilers allow a feature known as function overloading, which means that more than one function (in the same scope) can share the same name -- as long as they have different parameter lists.

Note: This is specifically a newer C++ feature, but this means that some compiler environments that support both C and C++ may support this feature for C programs, as well.

Officially, this is a C++ feature.

• The rationale is that the compiler must be able to look at any function call and decide exactly which function is being invoked
• Overloading allows intuitive function names to be used in multiple contexts
• The parameter list can differ in number of parameters, or types of parameters, or both
• Example: The following 3 functions are considered different and distinguishable by the compiler, as they have different parameter lists

     int Process(double num);		  // function 1
     int Process(char letter);              // function 2
     int Process(double num, int position); // function 3
  

• Sample calls, based on the above declarations

     int x;
     double y = 12.34;
     x = Process(3.45, 12);	// invokes function 3
     x = Process('f');		// invokes function 2
     x = Process(y);		// invokes function 1
  

• Try this example here

Avoiding Ambiguity

• Even with legally overloaded functions, it's possible to make ambiguous function calls, largely due to automatic type conversions.
• Consider these functions

    void DoTask(int x, double y);
    void DoTask(double a, int b);
  

• These functions are legally overloaded. The first two calls below are fine. The third one is ambiguous:

    DoTask(4, 5.9);	// calls function 1
    DoTask(10.4, 3);	// calls function 2
    DoTask(1, 2);		// ambiguous due to type conversion (int -> double)