C++ Primer Plus

const Stock & Stock::topval(const Stock & s) const

{

    if (s.total_val > total_val)

        return s;

    else

        return *this;

}

Of course, you want to see if the this pointer works, and a natural place to use the new method is in a program with an array of objects, which leads us to the next topic.

An Array of Objects

Often, as with the Stock examples, you want to create several objects of the same class. You can create separate object variables, as the examples have done so far in this chapter, but it might make more sense to create an array of objects. That might sound like a major leap into the unknown, but, in fact, you declare an array of objects the same way you declare an array of any of the standard types:

Stock mystuff[4]; // creates an array of 4 Stock objects

Recall that a program always calls the default class constructor when it creates class objects that aren’t explicitly initialized. This declaration requires either that the class explicitly define no constructors at all, in which case the implicit do-nothing default constructor is used, or, as in this case, that an explicit default constructor be defined. Each element—mystuff[0], mystuff[1], and so on—is a Stock object and thus can be used with the Stock methods:

mystuff[0].update();      // apply update() to 1st element

mystuff[3].show();        // apply show() to 4th element

const Stock * tops = mystuff[2].topval(mystuff[1]);

      // compare 3rd and 2nd elements and set tops

      // to point at the one with a higher total value

You can use a constructor to initialize the array elements. In that case, you have to call the constructor for each individual element:

const int STKS = 4;

Stock stocks[STKS] = {

    Stock("NanoSmart", 12.5, 20),

    Stock("Boffo Objects", 200, 2.0),

    Stock("Monolithic Obelisks", 130, 3.25),

    Stock("Fleep Enterprises", 60, 6.5)

    };

Here the code uses the standard form for initializing an array: a comma-separated list of values enclosed in braces. In this case, a call to the constructor method represents each value. If the class has more than one constructor, you can use different constructors for different elements:

const int STKS = 10;

Stock stocks[STKS] = {

    Stock("NanoSmart", 12.5, 20),

    Stock(),

    Stock("Monolithic Obelisks", 130, 3.25),

};

This initializes stocks[0] and stocks[2] using the Stock(const string & co, long n, double pr) constructor as well as stocks[1] using the Stock() constructor. Because this declaration only partially initializes the array, the remaining seven members are initialized using the default constructor.

Listing 10.9 applies these principles to a short program that initializes four array elements, displays their contents, and tests the elements to find the one with the highest total value. Because topval() examines just two objects at a time, the program uses a for loop to examine the whole array. Also it uses a pointer-to-Stock to keep track of which element has the highest value. This listing uses the Listing 10.7 header file and the Listing 10.8 methods file.

Listing 10.9. usestok2.cpp

// usestok2.cpp -- using the Stock class

// compile with stock20.cpp

#include

#include "stock20.h"

const int STKS = 4;

int main()

{

// create an array of initialized objects

    Stock stocks[STKS] = {

        Stock("NanoSmart", 12, 20.0),

        Stock("Boffo Objects", 200, 2.0),

        Stock("Monolithic Obelisks", 130, 3.25),

        Stock("Fleep Enterprises", 60, 6.5)

        };

    std::cout << "Stock holdings:\n";

    int st;

    for (st = 0; st < STKS; st++)

        stocks[st].show();

// set pointer to first element

    const Stock * top = &stocks[0];

    for (st = 1; st < STKS; st++)

        top = &top->topval(stocks[st]);

// now top points to the most valuable holding

    std::cout << "\nMost valuable holding:\n";

    top->show();

     return 0;

}

Here is the output from the program in Listing 10.9:

Stock holdings:

Company: NanoSmart  Shares: 12

  Share Price: $20.000  Total Worth: $240.00

Company: Boffo Objects  Shares: 200

  Share Price: $2.000  Total Worth: $400.00

Company: Monolithic Obelisks  Shares: 130

  Share Price: $3.250  Total Worth: $422.50

Company: Fleep Enterprises  Shares: 60

  Share Price: $6.500  Total Worth: $390.00

Most valuable holding:

Company: Monolithic Obelisks  Shares: 130

  Share Price: $3.250  Total Worth: $422.50

One thing to note about Listing 10.9 is that most of the work goes into designing the class. When that’s done, writing the program itself is rather simple.

Incidentally, knowing about the this pointer makes it easier to see how C++ works under the skin. For example, the original Unix implementation used a C++ front-end cfront that converted C++ programs to C programs. To handle method definitions, all it had to do is convert a C++ method definition like

void Stock::show() const

{

    cout << "Company: " << company

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

         << "  Share Price: $" << share_val

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

}

to the following C-style definition:

void show(const Stock * this)

{

    cout << "Company: " << this->company

         << "  Shares: " << this->shares << '\n'

         << "  Share Price: $" << this->share_val