C++ Primer Plus

Answers to Chapter Review for Chapter 15

1.

a. The friend declaration should be as follows:

friend class clasp;

b. This needs a forward declaration so that the compiler can interpret void snip(muff &):

class muff;    // forward declaration

class cuff {

public:

    void snip(muff &) { ... }

    ...

};

class muff {

    friend void cuff::snip(muff &);

    ...

};

c. First, the cuff class declaration should precede the muff class so that the compiler can understand the term cuff::snip(). Second, the compiler needs a forward declaration of muff so that it can understand snip(muff &):

class muff;    // forward declaration

class cuff {

public:

    void snip(muff &) { ... }

    ...

};

class muff {

    friend void cuff::snip(muff &);

    ...

};

2. No. For Class A to have a friend that’s a member function of Class B, the B declaration must precede the A declaration. A forward declaration is not enough because it would tell A that B is a class, but it wouldn’t reveal the names of the class members. Similarly, if B has a friend that’s a member function of A, the complete A declaration must precede the B declaration. These two requirements are mutually exclusive.

3. The only access to a class is through its public interface, which means the only thing you can do with a Sauce object is call the constructor to create one. The other members (soy and sugar) are private by default.

4. Suppose the function f1() calls the function f2(). A return statement in f2() causes program execution to resume at the next statement following the f2() function call in function f1(). A throw statement causes the program to back up through the current sequence of function calls until it finds a try block that directly or indirectly contains the call to f2(). This might be in f1() or in a function that called f1(), and so on. Once there, execution goes to the next matching catch block, not to the first statement after the function call.

5. You should arrange the catch blocks in order, from most derived class to least derived.

6. For Sample #1, the if condition is true if pg points to a Superb object or to an object of any class descended from Superb. In particular, it is also true if pg points to a Magnificent object. In Sample #2, the if condition is true only for a Superb object, not for objects derived from Superb.

7. The dynamic_cast operator only allows upcasting in a class hierarchy, whereas a static_cast operator allows both upcasting and downcasting. The static_cast operator also allows conversions from enumeration types to integer types, and vice versa, and between various numeric types.

Answers to Chapter Review for Chapter 16

1.

#include

using namespace std;

class RQ1

{

private:

    string st;       // a string object

public:

    RQ1() : st("") {}

    RQ1(const char * s) : st(s) {}

    ~RQ1() {};

// more stuff

};

The explicit copy constructor, destructor, and assignment operator are no longer needed because the string object provides its own memory management.

2. You can assign one string object to another. A string object provides its own memory management so that you normally don’t have to worry about a string exceeding the capacity of its holder.

3.

#include

#include

using namespace std;

void ToUpper(string & str)

{

    for (int i = 0; i < str.size(); i++)

        str[i] = toupper(str[i]);

}

4.

auto_ptr pia= new int[20];  // wrong, use with new, not new[]

auto_ptr(new string);    // wrong, no name for pointer

int rigue = 7;

auto_ptr(&rigue);           // wrong, memory not allocated by new

auto_ptr dbl (new double);       // wrong, omits

5. The LIFO aspect of a stack means you might have to remove a lot of clubs before reaching the one you need.

6. The set will store just one copy of each value, so, say, five scores of 5 would be stored as a single 5.

7. Using iterators allows you to use objects with a pointer-like interface to move through data that is organized in some fashion other than an array (for example, data in a doubly linked list).

8. The STL approach allows STL functions to be used with ordinary pointers to ordinary arrays as well as with iterators to STL container classes, thus increasing generality.

9. You can assign one vector object to another. A vector manages its own memory, so you can insert items into a vector and have it resize itself automatically. By using the at() method, you can get automatic bounds checking.