C++ Primer Plus

These tools can be used in the show() method to control the formatting, but there is another point to consider. When you change the implementation for a method, the changes should not affect other parts of the client program. The format changes just mentioned stay in place until changed again, so they could affect subsequent output in the client program. Therefore, the polite thing for show() to do is to reset the formatting information to the state that existed before show() was called. This can be done, as in Listing 8.8, using return values for the setting statements:

std::streamsize prec =

    std::cout.precision(3);  // save preceding value for precision

...

std::cout.precision(prec);           // reset to old value

// store original flags

std::ios_base::fmtflags orig = std::cout.setf(std::ios_base::fixed);

...

// reset to stored values

std::cout.setf(orig, std::ios_base::floatfield);

As you may recall, fmtflags is a type defined in the ios_base class, which is defined in the std namespace, hence the rather long type name for orig. Second, orig holds all the flags, and the reset statement uses that information to reset information in the floatfield section, which includes flags for fixed-point notation and scientific notation. Third, let’s not worry too much about the details here. The main points are that the changes are confined to the implementation file and that the changes don’t affect other aspects of the program using the class.

Putting this information to use, we can replace the show() definition in the implementation file with this:

void Stock::show()

{

    using std::cout;

    using std::ios_base;

    // set format to #.###

    ios_base::fmtflags orig =

        cout.setf(ios_base::fixed, ios_base::floatfield);

    std::streamsize prec = cout.precision(3);

    cout << "Company: " << company

        << "  Shares: " << shares << '\n';

    cout << "  Share Price: $" << share_val;

    // set format to #.##

    cout.precision(2);

    cout << "  Total Worth: $" << total_val << '\n';

    // restore original format

    cout.setf(orig, ios_base::floatfield);

    cout.precision(prec);

}

After this replacement and leaving the header file and client file unchanged, you can recompile the program. Now the output would look like this:

Company: NanoSmart  Shares: 20

  Share Price: $12.500  Total Worth: $250.00

Company: NanoSmart  Shares: 35

  Share Price: $18.125  Total Worth: $634.38

You can't sell more than you have! Transaction is aborted.

Company: NanoSmart  Shares: 35

  Share Price: $18.125  Total Worth: $634.38

Company: NanoSmart  Shares: 300035

  Share Price: $40.125  Total Worth: $12038904.38

Company: NanoSmart  Shares: 35

  Share Price: $0.125  Total Worth: $4.38

Reviewing Our Story to Date

The first step in specifying a class design is to provide a class declaration. The class declaration is modeled after a structure declaration and can include data members and function members. The declaration has a private section, and members declared in that section can be accessed only through the member functions. The declaration also has a public section, and members declared there can be accessed directly by a program using class objects. Typically, data members go into the private section and member functions go into the public section, so a typical class declaration has this form:

class className

{

private:

    data member declarations

public:

    member function prototypes

};

The contents of the public section constitute the abstract part of the design, the public interface. Encapsulating data in the private section protects the integrity of the data and is called data hiding. Thus, using a class is the C++ way of making it easy to implement the OOP features abstraction, data hiding, and encapsulation.

The second step in specifying a class design is to implement the class member functions. You can use a complete function definition instead of a function prototype in the class declaration, but the usual practice, except with very brief functions, is to provide the function definitions separately. In that case, you need to use the scope-resolution operator to indicate to which class a member function belongs. For example, suppose the Bozo class has a member function called Retort() that returns a pointer to a char. The function header would look like this:

char * Bozo::Retort()

In other words, Retort() is not just a type char * function; it is a type char * function that belongs to the Bozo class. The full, or qualified, name of the function is Bozo::Retort(). The name Retort(), on the other hand, is an abbreviation of the qualified name, and it can be used only in certain circumstances, such as in the code for the class methods.

Another way of describing this situation is to say that the name Retort has class scope, so the scope-resolution operator is needed to qualify the name when it is used outside the class declaration and a class method.

To create an object, which is a particular example of a class, you use the class name as if it were a type name:

Bozo bozetta;