Cpp Chapter 8: Adventures in Functions Part4

8.4 Function Overloading

) Function overloading, also called function polymorphism, lets you use multiple functions with the same name, but using different argument lists. The key to function overloading is a function's argument list, also called the function signature. The signature can differ in the number of arguments or in the type of arguments, or both.

) When there is one type mismatch between function calling and function prototype, C++ will accept this function call and conduct type conversion:

void process(double x, int y);
process(2,3); // acceptable, converting 2 to double(2.0)

But if the function call doen't match any of the prototypes while still could be converted to more than one prototype, C++ rejects this ambiguous function call:

void process(double x, int y);
void process(float x, int y);
process(2, 6); // invalid! 2 could be converted to both double and float

) This is not overloading:

void process(double x);
void process(double & x); // not overloading

due to the fact that the compiler considers a reference to a type and a type itself to be the same signature(to avoid ambiguous situations).

) The function-matching process also discriminates between const and non-const:

void process(double x);
void process(const double x); // overloaded

) Difference in the type of return value doesn't enable function overloading:

long process(double x);
double process(double x); // invalid!

Here's an example:

// leftover.cpp -- overloading the left() function
#include <iostream>
unsigned long left(unsigned long num, unsigned ct);
char * left(const char * str, int n = 1);

int main()
{
    using namespace std;
    char * trip = "Hawaii!!";
    unsigned long n = 12345678;
    int i;
    char * temp;

    for (i = 1; i < 10; i++)
    {
        cout << left(n,i) << endl;
        temp = left(trip,i);
        cout << temp << endl;
        delete [] temp;
    }
    return 0;
}

// This function returns the first ct digits of the number num
unsigned long left(unsigned long num, unsigned ct)
{
    unsigned digits = 1;
    unsigned long n = num;

    if (ct == 0 || num == 0)
        return 0;
    while (n/=10)
        digits++;
    if (digits > ct)
    {
        ct = digits - ct;
        while (ct--)
            num /= 10;
        return num;
    }
    else
        return num;
}

// This function returns a pointer to a new string consisting of the first n characters in the old string
char * left(const char * str, int n)
{
    if (n < 0)
        n = 0;
    char * p = new char[n+1];
    int i;
    for (int i = 0; i < n && str[i]; i++)
        p[i] = str[i];
    while (i <= n)
        p[i++] = '\0';
    return p;
}

) Function overloading should be reserved for functions that perform the same task with different forms of data. Default arguments are someties useful replacement of function overloading when you require less arguments than a original function.

) Name decoration is the way that C++ handles overloaded functions. It assigns a secret identity, or code to each of the functions.

8.5 Function Templates

) A function template is a generic function description, it defines a function of a generic type which could be converted to specific types while passed corresponding parameter.This is also called generic programming:

template <typename T>
void Swap(T &a, T &b)
{
    T temp;
    temp = a;
    a = b;
    b = temp;
}

The keyword typename(could also be class) and template are obligatory. T is your choice of name representing a generic type. When you use a template function, The complier checks the argument types you use and then generates the corresponding function.

) Here is an example of function templates:

// funtemp.cpp -- using a function template
#include <iostream>

template <typename T>
void Swap(T &a, T &b);

int main()
{
    using namespace std;
    int i = 10;
    int j = 20;
    cout << "i, j = " << i << ", " << j << ".\n";
    cout << "Using complier-generated int swapper:\n";
    Swap(i,j);
    cout << "Now i, j = " << i << ", " << j << ".\n";
    
    double x = 24.5;
    double y = 81.7;
    cout << "x, y = " << x << ", " << y << ".\n";
    cout << "Using complier-generated doulbe swapper:\n";
    Swap(x,y);
    cout << "Now x, y = " << x << ", " << y << ".\n";
    return 0;
}

template <typename T>
void Swap(T &a, T &b)
{
    T temp;
    temp = a;
    a = b;
    b = temp;
}

generally, the calling Swap(i,j) on line 14 will generate this function:

void Swap(int &a, int &j)
{
    int temp;
    temp = a;
    a = b;
    b = temp;
}

So using function templates doen't shorten code, it just provides extra reliability and save your precious time from making petty changes to functions.