C++ Primer Plus

    char fullname[SLEN];

    char hobby[SLEN];

    int ooplevel;

};

// getinfo() has two arguments: a pointer to the first element of

// an array of student structures and an int representing the

// number of elements of the array. The function solicits and

// stores data about students. It terminates input upon filling

// the array or upon encountering a blank line for the student

// name. The function returns the actual number of array elements

// filled.

int getinfo(student pa[], int n);

// display1() takes a student structure as an argument

// and displays its contents

void display1(student st);

// display2() takes the address of student structure as an

// argument and displays the structure's contents

void display2(const student * ps);

// display3() takes the address of the first element of an array

// of student structures and the number of array elements as

// arguments and displays the contents of the structures

void display3(const student pa[], int n);

int main()

{

     cout << "Enter class size: ";

     int class_size;

     cin >> class_size;

     while (cin.get() != '\n')

         continue;

    student * ptr_stu = new student[class_size];

    int entered = getinfo(ptr_stu, class_size);

    for (int i = 0; i < entered; i++)

    {

        display1(ptr_stu[i]);

        display2(&ptr_stu[i]);

    }

    display3(ptr_stu, entered);

    delete [] ptr_stu;

    cout << "Done\n";

    return 0;

}

10. Design a function calculate() that takes two type double values and a pointer to a function that takes two double arguments and returns a double. The calculate() function should also be type double, and it should return the value that the pointed-to function calculates, using the double arguments to calculate(). For example, suppose you have this definition for the add() function:

double add(double x, double y)

{

       return x + y;

}

Then, the function call in the following would cause calculate() to pass the values 2.5 and 10.4 to the add() function and then return the add() return value (12.9):

double q = calculate(2.5, 10.4, add);

Use these functions and at least one additional function in the add() mold in a program. The program should use a loop that allows the user to enter pairs of numbers. For each pair, use calculate() to invoke add() and at least one other function. If you are feeling adventurous, try creating an array of pointers to add()-style functions and use a loop to successively apply calculate() to a series of functions by using these pointers. Hint: Here’s how to declare such an array of three pointers:

double (*pf[3])(double, double);

You can initialize such an array by using the usual array initialization syntax and function names as addresses.

8. Adventures in Functions

In this chapter you’ll learn about the following:

• Inline functions

• Reference variables

• How to pass function arguments by reference

• Default arguments

• Function overloading

• Function templates

• Function template specializations

With Chapter 7, “Functions: C++’s Programming Modules,” under your belt, you now know a lot about C++ functions, but there’s much more to come. C++ provides many new function features that separate C++ from its C heritage. The new features include inline functions, by-reference variable passing, default argument values, function overloading (polymorphism), and template functions. This chapter, more than any other you’ve read so far, explores features found in C++ but not C, so it marks your first major foray into plus-plussedness.

C++ Inline Functions

Inline functions are a C++ enhancement designed to speed up programs. The primary distinction between normal functions and inline functions is not in how you code them but in how the C++ compiler incorporates them into a program. To understand the distinction between inline functions and normal functions, you need to peer more deeply into a program’s innards than we have so far. Let’s do that now.