C++ Primer Plus

In this chapter we’ve already developed a left() function that returns a pointer to the first n characters in a string. Let’s add a second left() function, one that returns the first n digits in an integer. You can use it, for example, to examine the first three digits of a U.S. postal zip code stored as an integer, which is useful if you want to sort for urban areas.

The integer function is a bit more difficult to program than the string version because you don’t have the benefit of each digit being stored in its own array element. One approach is to first compute the number of digits in the number. Dividing a number by 10 lops off one digit, so you can use division to count digits. More precisely, you can do so with a loop, like this:

unsigned digits = 1;

while (n /= 10)

    digits++;

This loop counts how many times you can remove a digit from n until none are left. Recall that n /= 10 is short for n = n / 10. If n is 8, for example, the test condition assigns to n the value 8 / 10, or 0, because it’s integer division. That terminates the loop, and digits remains at 1. But if n is 238, the first loop test sets n to 238 / 10, or 23. That’s nonzero, so the loop increases digits to 2. The next cycle sets n to 23 / 10, or 2. Again, that’s nonzero, so digits grows to 3. The next cycle sets n to 2 / 10, or 0, and the loop quits, leaving digits set to the correct value, 3.

Now suppose you know that the number has five digits, and you want to return the first three digits. You can get that value by dividing the number by 10 and then dividing the answer by 10 again. Each division by 10 lops one more digit off the right end. To calculate the number of digits to lop, you just subtract the number of digits to be shown from the total number of digits. For example, to show four digits of a nine-digit number, you lop off the last five digits. You can code this approach as follows:

ct = digits - ct;

while (ct--)

    num /= 10;

return num;

Listing 8.10 incorporates this code into a new left() function. The function includes some additional code to handle special cases, such as asking for zero digits or asking for more digits than the number possesses. Because the signature of the new left() differs from that of the old left(), you can use both functions in the same program.

Listing 8.10. leftover.cpp

// leftover.cpp -- overloading the left() function

#include

unsigned long left(unsigned long num, unsigned ct);

char * left(const char * str, int n = 1);

int main()

{

     using namespace std;

    char * trip = "Hawaii!!";   // test value

    unsigned long n = 12345678; // test value

    int i;

    char * temp;

    for (i = 1; i < 10; i++)

    {

        cout << left(n, i) << endl;

        temp = left(trip,i);

        cout << temp << endl;

        delete [] temp; // point to temporary storage

    }

    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;       // return 0 if no digits

    while (n /= 10)

        digits++;

    if (digits > ct)

    {

    ct = digits - ct;

    while (ct--)

        num /= 10;

    return num;         // return left ct digits

    }

    else                // if ct >= number of digits

        return num;     // return the whole number

}

// This function returns a pointer to a new string

// consisting of the first n characters in the str string.

char * left(const char * str, int n)

{

    if(n < 0)

        n = 0;

    char * p = new char[n+1];

    int i;

    for (i = 0; i < n && str[i]; i++)

        p[i] = str[i];  // copy characters

    while (i <= n)

        p[i++] = '\0';  // set rest of string to '\0'

    return p;

}

Here’s the output of the program in Listing 8.10:

1

H

12

Ha

123

Haw

1234

Hawa

12345

Hawai

123456

Hawaii

1234567

Hawaii!

12345678

Hawaii!!

12345678

Hawaii!!

When to Use Function Overloading

You might find function overloading fascinating, but you shouldn’t overuse it. You should reserve function overloading for functions that perform basically the same task but with different forms of data. Also you might want to check whether you can accomplish the same end by using default arguments. For example, you could replace the single, string-oriented left() function with two overloaded functions:

char * left(const char * str, unsigned n);   // two arguments

char * left(const char * str);               // one argument

But using the single function with a default argument is simpler. There’s just one function to write instead of two, and the program requires memory for just one function instead of two. If you decide to modify the function, you have to edit only one. However, if you require different types of arguments, default arguments are of no avail, so in that case, you should use function overloading.

What Is Name Decoration?