Cpp Chapter 8: Adventures in Functions Part3

8.2.6 Objects, Inheritance, and References

) You might use ostream object cout and ofstream object fout(your declaration), and the object fout could share the methods of ostream class. The language features of passing class features from one to another is called class inheritance. In this example, ostream is termed base class and ofstream is termed derived class. Methods like precision() and setf() in ostream class is also available to ofstream class objects, so you could use same methods will handing console output and file output.

) A base class reference could refer to a derived class object without type cast.

The following example illustrates these features:

// filefunc.cpp -- function with ostream & parameter
#include <iostream>
#include <fstream>
#include <cstdlib>
using namespace std;

void file_it(ostream & os, double fo, const double fe[], int n);
const int LIMIT = 5;
int main()
{
    ofstream fout;
    const char * fn = "ep-data.txt";
    fout.open(fn);
    if (!fout.is_open())
    {
        cout << "Can't open " << fn << ". Bye.
";
        exit(EXIT_FAILURE);
    }
    double objective;
    cout << "Enter the focal length of your telescope objective in mm: ";
    cin >> objective;
    double eps[LIMIT];
    cout << "Enter the focal lengths, in mm, of " << LIMIT << " eyepieces:
";
    for (int i = 0; i < LIMIT; i++)
    {
        cout << "Eyepiece #" << i+1 << ": ";
        cin >> eps[i];
    }
    file_it(fout, objective, eps, LIMIT);
    file_it(cout, objective, eps, LIMIT);
    cout << "Done
";
    return 0;
}

void file_it(ostream & os, double fo, const double fe[], int n)
{
    ios_base::fmtflags initial;
    initial = os.setf(ios_base::fixed); // save initial formatting state
    os.precision(0);
    os << "Focal length of objective: " << fo << " mm
";
    os.setf(ios::showpoint);
    os.precision(1);
    os.width(12);
    os << "f.l. eyepiece";
    os.width(15);
    os << "magnification" << endl;
    for (int i = 0; i < n; i++)
    {
        os.width(12);
        os << fe[i];
        os.width(15);
        os << int(fo / fe[i] + 0.5) << endl;
    }
    os.setf(initial);
}

29-30) file_it() recieves an ostream-class reference as first parameter, here passes fout and cout consecutively, proving that base-class reference could also accpet derive-class objects without type cast, so these two lines print stuff on console and print it in a file, both using ostream class formatting features.

39/42) precision() specifies the number of digits displayed right to the decimal

43/45/49/51) width() specifies output width range for next output(width(0) means no mandatory stretch or trimming: just display it according to its original quantity)

37/38/54) Code like this is observed:

ios_base::fmtflags initial;
initial = os.setf(ios_base::fixed);
...
os.setf(initial);

The first row declares a variable initial as type ios_base::fmtflags for storing initial pattern. Then initial was assigned to the return value of os.setf(), which returns the original format settings of the ostream object before "setf". After the process, it uses os.setf(initial) to retain the initial formatting by using the stored initial pattern.

8.2.7 When to Use Reference Arguments

There are two main reasons for using reference arguments:

1) To allow you to alter a data object in the calling function

2) To speed up the program by passing a reference instead of an entire data object

Guidelines of choosing between reference, pointer and passing by value:

	No data modifying	modify data
build-in data type	pass by value	pointer
array	const pointer	pointer
structure	const pointer/reference	pointer/reference
class object	const reference	reference

8.3 Default Arguments

) A default argument is a value that's used automatically if you omit the corresponding actual argument from a function call.

) Use function prototype for default arguments.

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

In this way you make n a default argument, if you omit value of n, the program will take n for 1.

left(arr, 1);
left(arr);// functions in the same way

) When using a function with an argument list, you must add defaults from left to right:

int f1(int n, int m = 4, int l = 5); // valid
int f2(int n, int m = 3, int l); // invalid
int f3(int n = 1, int m = 2, int l = 3); // valid

For instance, the f1() allows calls with one/two/three parameters. You can't skip arguments like this:

f1(2, , 3); // invalid, doesn't set m to 4

The following exapmle illustrates the features:

// left.cpp -- string function with a default argument
#include <iostream>
const int ArSize = 80;
char * left(const char * str, int n = 1);
int main()
{
    using namespace std;
    char sample[ArSize];
    cout << "Enter a string:
";
    cin.get(sample, ArSize);
    char *ps = left(sample, 4);
    cout << ps << endl;
    delete [] ps;
    ps = left(sample);
    cout << ps << endl;
    delete [] ps;
    return 0;
}

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++] = '';
    return p;
}