Why does C++ have more than one integer type?

Having more than one integer type lets you choose the type best suited to a particular need. For example, you could use short to conserve space, long to guarantee storage capacity, or find that a particular type speeds up a particular calculation.

Define the following:

What safeguards does C++ provide to keep you from exceeding the limits of an integer type?

C++ provides no automatic safeguards to keep you from exceeding integer limits; you can use the climits header file to determine what the limits are.

What is the distinction between 33L and 33?

The constant 33L is type long, whereas the constant 33 is type int.

Consider the two C++ statements that follow. Are they equivalent?

char grade = 65;
char grade = 'A';

The two statements are not really equivalent, although they have the same effect on some systems. Most important, the first statement assigns the letter A to grade only on a system using the ASCII code, while the second statement also works for other codes. Second, 65 is a type int constant, while 'A' is a type char constant.

How could you use C++ to find out which character the code 88 represents? Come up with at least two ways.

Here are four ways:

char c = 88;
cout << c << "\n";          // char type prints as character
cout.put(char(88));         // put() prints char as character
cout << char(88) << "\n";    // new-style type cast value to char
cout << (char)88 << "\n";    // old-style type cast value to char

Assigning a long value to a float can result in a round-off error. What about assigning long to double?

The answer depends on how large the two types are. If long is 4 bytes, there is no loss. That's because the largest long value would be about 2 billion, which is 10 digits. Because double provides at least 13 significant figures, no rounding would be needed.

Evaluate the following expressions as C++ would:

Suppose x1 and x2 are two type double variables that you want to add as integers and assign to an integer variable. Construct a C++ statement for doing so.

Either of the following work:

int pos = (int) x1 + (int) x2;
int pos = int(x1) + int(x2);

How would you declare each of the following?

Declare an array of five ints and initialize it to the first five odd positive integers.

Write a statement that assigns the sum of the first and last elements of the array in question 2 to the variable even.

Write a statement that displays the value of the second element in the float array ideas.

Declare an array of char and initialize it to the string "cheeseburger".

Devise a structure declaration that describes a fish. The structure should include the kind, the weight in whole ounces, and the length in fractional inches.

Declare a variable of the type defined in question 6 and initialize it.

Use enum to define a type called Response with the possible values of Yes, No, and Maybe. Yes should be 1, No should be 0, and Maybe should be 2.

Suppose ted is a double variable. Declare a pointer that points to ted and use the pointer to display ted's value.

Suppose treacle is an array of 10 floats. Declare a pointer that points to the first element of treacle and use the pointer to display the first and last elements of the array.

Write a code fragment that asks the user to enter a positive integer and then creates a dynamic array of that many ints.

Is the following valid code? If so, what does it print?

Yes, it is valid. The expression "Home of the jolly bytes" is a string constant, hence it evaluates as the address of the beginning of the string. The cout object interprets the address of a char as an invitation to print a string, but the type cast (int *) converts the address to type pointer-to-int, which is then printed as an address. In short, the statement prints the address of the string.

Write a code fragment that dynamically allocates a structure of the type described in question 6 and then reads a value for the kind member of the structure.

Listing 4.6 illustrates a problem with the following numeric input with line-oriented string input. How would replacing

cin.getline(address,80);

with

cin >> address;

affect the working of this program?

Using cin >> address causes a program to skip over whitespace until it finds nonwhitespace. It then reads characters until it encounters whitespace again. Thus, it will skip over the newline following the numeric input, avoiding that problem. On the other hand, it will read just a single word, not an entire line.

Consider the following two code fragments for counting spaces and newlines:

// Version 1
while (cin.get(ch))    // quit on eof
{
      if (ch == ' ')
             spaces++;
      if (ch == '\n')
            newlines++;
}
// Version 2
while (cin.get(ch))    // quit on eof
{
      if (ch == ' ')
            spaces++;
      else if (ch == '\n')
            newlines++;
}

What advantages, if any, does the second form have over the first?

Both versions give the same answers, but the if else version is more efficient. Consider what happens, for example, when ch is a space. Version 1, after incrementing spaces, tests to see whether the character is a newline. This wastes time because the program already has established that ch is a space and hence could not be a newline. Version 2, in the same situation, skips the newline test.

In Listing 6.2, what is the effect of replacing ++ch with ch+1?

Both ++ch and ch + 1 have the same numerical value. But ++ch is type char and prints as a character, while ch + 1, because it adds a char to an int, is type int and prints as a number.

Consider carefully the following program:

#include <iostream>
using namespace std;
int main()
{
    char ch;
    int ct1, ct2;
    ct1 = ct2 = 0;
    while ((ch = cin.get()) != '$')
    {
        cout << ch;
        ct1++;
        if (ch = '$')
            ct2++;
        cout << ch;
    }
    cout <<"ct1 = " << ct1 << ", ct2 = " << ct2 << "\n";
    return 0;
}

Suppose we provide the following input, where represents pressing Enter:

Hi!
Send $10 or $20 now!

What is the output? (Recall that input is buffered.)

Because the program uses ch = '$' instead of ch == '$', the combined input and output looks like this:

Hi!
H$i$!$
$Send $10 or $20 now!
S$e$n$d$ $ct1 = 9, ct2 = 9

Each character is converted to the $ character before being printed the second time. Also, the value of the expression ch = $ is the code for the $ character, hence nonzero, hence true; so ct2 is incremented each time.

Construct logical expressions to represent the following conditions:

In English the statement "I will not not speak" means the same as "I will speak." In C++, is !!x the same as x?

Not necessarily. For example, if x is 10, then !x is 0 and !!x is 1. However, if x is a bool variable, then !!x is x.

Construct a conditional expression that is equal to the absolute value of a variable. That is, if a variable x is positive, the value of the expression is just x, but if x is negative, the value of the expression is -x, which is positive.

Rewrite the following fragment using switch:

if (ch == 'A')
    a_grade++;
else if (ch == 'B')
    b_grade++;
else if (ch == 'C')
    c_grade++;
else if (ch == 'D')
    d_grade++;
else
    f_grade++;

In Listing 6.10, what advantage would there be in using character labels, such as a and c, instead of numbers for the menu choices and switch cases? (Hint: Think about what happens if the user types q in either case and what happens if the user types 5 in either case.)

If you use integer labels and the user types a noninteger such as q, the program hangs up because integer input can't process a character. But if you use character labels and the user types an integer such as 5, character input will process 5 as a character. Then the default part of the switch can suggest entering another character.

Consider the following code fragment:

int line = 0;
char ch;
while (cin.get(ch))
{
    if (ch == 'Q')
           break;
    if (ch != '\n')
           continue;
    line++;
}

Rewrite this code without using break or continue.

Here is one version:

int line = 0;
char ch;
while (cin.get(ch) && ch != 'Q')
{
    if (ch == '\n')
        line++;
}

What are the three steps in using a function?

The three steps are defining the function, providing a prototype, and calling the function.

Construct function prototypes that match the following descriptions:

Write a function that takes three arguments: the name of an int array, the array size, and an int value. Have the function set each element of the array to the int value.

Write a function that takes three arguments: a pointer to the first element of a range in an array, a pointer to the element following the end of a range in an array, and an int value. Have the function set each element of the array to the int value.

Write a function that takes a double array name and an array size as arguments and returns the largest value in that array. Note that this function shouldn't alter the contents of the array.

Why don't we use the const qualifier for function arguments that are one of the fundamental types?

We use the const qualifier with pointers to protect the original pointed-to data from being altered. When a program passes a fundamental type such as an int or double, it passes it by value so that the function works with a copy. Thus, the original data is already protected.

What are the three forms a C-style string can take in a C++ program?

A string can be stored in a char array, it can be represented by a string constant in double quotation marks, and it can be represented by a pointer pointing to the first character of a string.

Write a function that has this prototype:

int replace(char * str, char c1, char c2);

Have the function replace every occurrence of c1 in the string str with c2, and have the function return the number of replacements it makes.

What does the expression *"pizza" mean? What about "taco"[2]?

What does the expression *"pizza" mean? What about "taco"[2]?

Because C++ interprets "pizza" as the address of its first element, applying the * operator yields the value of that first element, which is the character p. Because C++ interprets "taco" as the address of its first element, it interprets "taco"[2] as the value of the element two positions down the line, that is, as the character c. In other words, the string constant acts the same as an array name.

C++ enables you to pass a structure by value and it lets you pass the address of a structure. If glitz is a structure variable, how would you pass it by value? How would you pass its address? What are the trade-offs of the two approaches?

To pass it by value, just pass the structure name glitz. To pass its address, use the address operator &glitz. Passing by value automatically protects the original data, but it takes time and memory. Passing by address saves time and memory but doesn't protect the original data unless you use the const modifier for the function parameter. Also, passing by value means you can use ordinary structure member notation, but passing a pointer means you have to remember to use the indirect membership operator.

The function judge() has a type int return value. As an argument, it takes the address of a function that takes a pointer to a const char as an argument and that also returns an int. Write the function prototype.

What kinds of functions are good candidates for inline status?

Short, non-recursive functions that can fit in one line of code.

Suppose the song() function has this prototype:

void song(char * name, int times);

Write overloaded versions of iquote(), a function that displays its argument enclosed in double quotation marks. Write three versions: one for an int argument, one for a double argument, and one for a string argument.

You can use either the string "\"" or the character '"' to print a quotation mark. The following functions show both methods.

#include <iostream.h>
void iquote(int n)
{
    cout << "\"" << n << "\"";
}
void iquote(double x)
{
    cout << '"' << x << '"';
}
void iquote(const char * str)
{
    cout << "\"" << str << "\"";
}

Here is a structure template:

Here are some desired effects. Indicate whether each can be accomplished with default arguments, function overloading, both, or neither. Provide appropriate prototypes.

Write a function template that returns the larger of its two arguments.

Given the template of Review Question 6 and the box structure of Review Question 4, provide a template specialization that takes two box arguments and returns the one with the larger volume.

What storage scheme would you use for the following situations?

Discuss the differences between a using-declaration and a using-directive.

A using declaration makes a single name from a namespace available, and it has the scope corresponding to the declarative region in which the using declaration occurs. A using directive makes all the names in a namespace available. When you use a using directive, it is as if you declared the names in the smallest declarative region containing both the using declaration and the namespace itself.

Rewrite the following so that it doesn't use using-declarations or using-directives.

#include <iostream>
using namespace std;
int main()
{
    double x;
    cout << "Enter value: ";
    while (! (cin >> x) )
    {
        cout << "Bad input. Please enter a number: ";
        cin.clear();
       while (cin.get() != '\n')
           continue;
    }
    cout << "Value = " << x << endl;
    return 0;
}

Rewrite the following so that it uses using-declarations instead of the using-directive.

#include <iostream>
using namespace std;
int main()
{
    double x;
    cout << "Enter value: ";
    while (! (cin >> x) )
    {
        cout << "Bad input. Please enter a number: ";
        cin.clear();
       while (cin.get() != '\n')
           continue;
    }
    cout << "Value = " << x << endl;
    return 0;
}

Rewrite the following so that it uses using declarations instead of the using directive.

#include <iostream>
int main()
{
    using std::cin;
    using std::cout;
    using std::endl;
    double x;
    cout << "Enter value: ";
    while (! (cin >> x) )
    {
        cout << "Bad input. Please enter a number: ";
        cin.clear();
       while (cin.get() != '\n')
           continue;
    }
    cout << "Value = " << x << endl;
    return 0;
}

The average(3,6) function returns an int average of the two int arguments when called in one file, and it returns a double average of the two int arguments when called in a second file in the same program. How could you set this up?

You could have separate static function definitions in each file. Or each file could define the appropriate average() function in an unnamed namespace.

What will the following two-file program display?

// file1.cpp
#include <iostream>
using namespace std;
void other();
void another();
int x = 10;
int y;
int main()
{
    cout << x << endl;
    {
        int x = 4;
        cout << x << endl;
        cout << y << endl;
    }
    other();
    another();
    return 0;
}
void other()
{
    int y = 1;
    cout << "Other: " << x << "," << y << endl;
}
// file 2.cpp
#include <iostream>
using namespace std;
extern int x;
namespace
{
     int y = -4;
}
void another()
{
    cout << "another(): " << x << ", " << y << endl;
}

What will the following program display?

#include <iostream>
using namespace std;
void other();
namespace n1
{
    int x = 1;
}
namespace n2
{
    int x = 2;
}
int main()
{
   using namespace n1;
   cout << x << endl;
    {
        int x = 4;
        cout << x << ", " << n1::x << ", " << n2::x << endl;
    }
    using n2::x;
    cout << x << endl;
    other();
    return 0;
}
void other()
{
    using namespace n2;
    cout << x << endl;
    {
        int x = 4;
        cout << x << ", " << n1::x << ", " << n2::x << endl;
    }
    using n2::x;
    cout << x << endl;
}

Use a member function to overload the multiplication operator for the Stonewt class; have the operator multiply the data members by a type double value. Note that this will require carryover for the stone-pound representation. That is, twice 10 stone 8 pounds is 21 stone 2 pounds.

Here's a prototype for the class definition file and a function definition for the methods file:

// prototype
Stonewt operator*(double mult);
// definition -- let constructor do the work
Stonewt Stonewt::operator*(double mult)
{
    return Stonewt(mult * pounds);
}

What are the differences between a friend function and a member function?

A member function is part of a class definition and is invoked by a particular object. The member function can access members of the invoking object implicitly, without using the membership operator. A friend function is not part of a class, so it's called as a straight function call. It can't access class members implicitly, so it must use the membership operator applied to an object passed as an argument. Compare, for instance, the answer to Review Question 1 with the answer to Review Question 4.

Does a nonmember function have to be a friend to access a class's members?

It must be a friend to access private members, but it doesn't have to be a friend to access public members.

Use a friend function to overload the multiplication operator for the Stonewt class; have the operator multiply the double value by the Stone value.

Here's a prototype for the class definition file and a function definition for the methods file:

// prototype
friend Stonewt operator*(double mult, const Stonewt & s);
// definition -- let constructor do the work
Stonewt operator*(double mult, const Stonewt & s)
{
    return Stonewt(mult * s.pounds);
}

Which operators cannot be overloaded?

The following five operators cannot be overloaded:

sizeof   .   .*   ::   ? :

What restriction applies to overloading the following operators? = () [] ->

These operators must be defined by using a member function.

Define a conversion function for the Vector class that converts a Vector to a type double value representing the vector's magnitude.

Here is a possible prototype and definition:

// prototype and inline definition
operator double () {return mag;}

Note, however, that it makes better sense to use the magval() method than to define this conversion function.

Suppose a String class has the following private members:

class String
{
private:
    char * str;    // points to string allocated by new
    int len;       // holds length of string
//...
} ;

Name three problems that may arise if you define a class in which a pointer member is initialized using new and indicate how they can be remedied.

First, when an object of that type expires, the data pointed to by the object's member pointer remains in memory, using space and remaining inaccessible because the pointer has been lost. That can be fixed by having the class destructor delete memory allocated by new in the constructor functions. Second, once the destructor deletes such memory, it may wind up trying to delete it twice if a program initialized one such object to another. That's because the default initialization of one object to another copies pointer values but does not copy the pointed-to data, producing two pointers to the same data. The solution is to define a class copy constructor that causes initialization to copy the pointed-to data. Third, assigning one object to another can produce the same situation of two pointers pointing to the same data. The solution is to overload the assignment operator so that it copies the data, not the pointers.

What class methods does the compiler generate automatically if you don't provide them explicitly? Describe how these implicitly generated functions behave.

C++ automatically provides the following member functions:

• A default constructor if you define no constructors

• A copy constructor if you don't define one

• An assignment operator if you don't define one

• A default destructor if you don't define one

• An address operator if you don't define one

The default constructor does nothing, but it allows you to declare arrays and uninitialized objects. The default copy constructor and the default assignment operator use memberwise assignment. The default destructor does nothing. The implicit address operator returns the address of the invoking object (that is, the value of the this pointer).

Identify and correct errors in the following class declaration:

class nifty
{
// data
    char personality[];
    int talents;
// methods
    nifty();
    nifty(char * s);
    ostream & operator<<(ostream & os, nifty & n);
}
nifty:nifty()
{
    personality = NULL;
    talents = 0;
}
nifty:nifty(char * s)
{
    personality = new char [strlen(s)];
    personality = s;
    talents = 0;
}
ostream & nifty:operator<<(ostream & os, nifty & n)
{
    os << n;
}

The personality member should be declared either as a character array or as a pointer-to-char. Or you could make it a String object. Here are two possible solutions, with changes (other than deletions) in boldface.

#include <iostream>
#include <cstring>
using namespace std;
class nifty
{
private: // optional
    char personality[40];    // provide array size
    int talents;
public: // needed
// methods
    nifty();
    nifty(const char * s);
    friend ostream & operator<<(ostream & os, const nifty & n);
};    // note closing semicolon
nifty::nifty()
{
    personality[0] = '\0';
    talents = 0;
}
nifty::nifty(const char * s)
{
    strcpy(personality, s);
    talents = 0;
}
ostream & operator<<(ostream & os, const nifty & n)
{
    os << n.personality << '\n';
    os << n.talent << '\n';
    return os;
}

Or you could do this:

#include <iostream>
#include <cstring>
using namespace std;
class nifty
{
private: // optional
    char * personality;    // create a pointer
    int talents;
public: // needed
// methods
    nifty();
    nifty(const char * s);
    nifty(const nifty & n);
    ~nifty() { delete personality; }
    nifty & operator=(const nifty & n) const;
    friend ostream & operator<<(ostream & os, const nifty & n);
};    // note closing semicolon
nifty::nifty()
{
    personality = NULL;
    talents = 0;
}
nifty::nifty(const char * s)
{
    personality = new char [strlen(s) + 1];
    strcpy(personality, s);
    talents = 0;
}
ostream & operator<<(ostream & os, const nifty & n)
{
    os << n.personality << '\n';
    os << n.talent << '\n';
    return os;
}

Consider the following class declaration:

class Golfer
{
private:
    char * fullname;       // points to string containing golfer's name
    int games;             // holds number of golf games played
    int * scores;          // points to first element of array of golf scores
public:
    Golfer();
    Golfer(const char * name, int g= 0);
     // creates empty dynamic array of g elements if g > 0
    Golfer(const Golfer & g);
    ~Golfer();
} ;

What does a derived class inherit from a base class?

The public members of the base class become public members of the derived class. The protected members of the base class become protected members of the derived class. The private members of the base class are inherited, but cannot be accessed directly. The answer to review question 2 provides the exceptions to these general rules.

What doesn't a derived class inherit from a base class?

The constructor methods are not inherited, the destructor is not inherited, the assignment operator is not inherited, and friends are not inherited.

Suppose the return type for the baseDMA::operator=() function were defined as void instead of baseDMA &. What effect, if any, would that have? What if the return type were baseDMA instead of baseDMA &?

If the return type were void, you would still be able to use single assignment but not chain assignment:

baseDMA magazine("Pandering to Glitz", 1);
baseDMA gift1, gift2, gift3;
gift1 = magazine;         // ok
gift 2 = gift3 = gift1;  // no longer valid

If the method returned an object instead of a reference, the method execution would be slowed a bit because the return statement would involve copying the object.

In what order are class constructors and class destructors called when a derived class object is created and deleted?

Constructors are called in the order of derivation, with the most ancestral constructor called first. Destructors are called in the opposite order.

If a derived class doesn't add any data members to the base class, does the derived class require constructors?

Yes, every class requires its own constructors. If the derived class adds no new members, the constructor can have an empty body, but it must exist.

Suppose a base class and a derived class both define a method of the same name and a derived class object invokes the method. What method is called?

Only the derived class method is called. It supersedes the base class definition. A base class method is called only if the derived class does not redefine the method or if you use the scope resolution operator. However, you really should declare as virtual any functions that will be redefined.

When should a derived class define an assignment operator?

The derived class should define an assignment operator if the derived class constructors use the new or new [] operator to initialize pointers that are members of that class. More generally, the derived class should define an assignment operator if the default assignment is incorrect for derived class members.

Can you assign the address of an object of a derived class to a pointer to the base class? Can you assign the address of an object of a base class to a pointer to the derived class?

Yes, you can assign the address of an object of a derived class to a pointer to the base class. You can assign the address of a base object to a pointer to a derived class (downcasting) only by making an explicit type cast, and it is not necessarily safe to use such a pointer.

Can you assign an object of a derived class to an object of the base class? Can you assign an object of a base class to an object of the derived class?

Yes, you can assign an object of a derived class to an object of the base class. Any data members new to the derived type are not passed to the base type, however. The program will use the base class assignment operator. Assignment in the opposite direction (base to derived) is possible only if the derived class defines a conversion operator, which is a constructor having a reference to the base type as its sole argument, or else defines an assignment operator with a base-class parameter.

Suppose you define a function that takes a reference to a base class object as an argument. Why can this function also use a derived class object as an argument?

It can do so because C++ allows a reference to a base type to refer to any type derived from that base.

Suppose you define a function that takes a base class object as an argument (that is, the function passes a base class object by value). Why can this function also use a derived class object as an argument?

Passing an object by value invokes the copy constructor. Since the formal argument is a base class object, the base class copy constructor is invoked. The copy constructor has as its argument a reference to the base class, and this reference can refer to the derived object passed as an argument. The net result is producing a new base class object whose members correspond to the base class portion of the derived object.

Why is it usually better to pass objects by reference than by value?

Passing an object by reference instead of by value enables the function to avail itself of virtual functions. Also, passing an object by reference instead of value may use less memory and time, particularly for large objects. The main advantage of passing by value is that it protects the original data, but you can accomplish the same end by passing the reference as a const type.

Suppose Corporation is a base class and PublicCorporation is a derived class. Also suppose that each class defines a head() member function, that ph is a pointer to the Corporation type, and that ph is assigned the address of a PublicCorporation object. How is ph->head() interpreted if the base class defines head() as a

If head() is a regular method, then ph->head() invokes Corporation::head(). If head() is a virtual function, then ph->head() invokes PublicCorporation::head().

What's wrong, if anything, with the following code?

class Kitchen
{
private:
    double kit_sq_ft;
public:
    Kitchen() { kit_sq_ft = 0.0; }
    virtual double area() {  return kit_sq_ft * kit_sq_ft; }
};
class House : public Kitchen
{
private:
    double all_sq_ft;
public:
    House() { all_sq_ft += kit_sq_ft;}
    double area(const char *s) {  cout << s; return all_sq_ft; }
};

First, the situation does not fit the is-a model, so public inheritance is not appropriate. Second, the definition of area() in House hides the Kitchen version of area() because the two methods have different signatures.

For each of the following sets of classes, indicate whether public or private derivation is more appropriate for the second column:

Suppose we have the following definitions:

class Frabjous {
private:
      char fab[20];
public:
      Frabjous(const char * s = "C++") : fab(s) {}
      virtual void tell() { cout << fab; }
};
class Gloam {
private:
      int glip;
      Frabjous fb;
public:
      Gloam(int g = 0, const char * s = "C++");
      Gloam(int g, const Frabjous & f);
      void tell();
};

Given that the Gloam version of tell() should display the values of glip and fb, provide definitions for the three Gloam methods.

Suppose we have the following definitions:

class Frabjous {
private:
      char fab[20];
public:
      Frabjous(const char * s = "C++") : fab(s) {}
      virtual void tell() { cout << fab; }
};
class Gloam : private Frabjous{
private:
      int glip;
public:
      Gloam(int g = 0, const char * s = "C++");
      Gloam(int g, const Frabjous & f);
      void tell();
};

Given that the Gloam version of tell() should display the values of glip and fab, provide definitions for the three Gloam methods.

Suppose we have the following definition, based on the Stack template of Listing 14.14 and the Worker class of Listing 14.11:

Stack<Worker *> sw;

Write out the class declaration that will be generated. Just do the class declaration, not the non-inline class methods.

Use the template definitions in this chapter to define the following:

• An array of String objects

• A stack of arrays of double

• An array of stacks of pointers to Worker objects

How many template class definitions are produced in Listing 14.19?

Describe the differences between virtual and nonvirtual base classes.

If two lines of inheritance for a class share a common ancestor, the class winds up with two copies of the ancestor's members. Making the ancestor class a virtual base class to its immediate descendants solves that problem.

What's wrong with the following attempts at establishing friends?

You've seen how to create mutual class friends. Can you create a more restricted form of friendship in which only some members of class B are friends to class A and some members of A are friends to B? Explain.

No. For A to have a friend that's a member function of B, the B declaration must precede the A declaration. A forward declaration is not enough, for 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.

What problems might the following nested class declaration have?

class Ribs
{
private:
    class Sauce
    {
          int soy;
          int sugar;
   public:
          Sauce(int s1, int s2) : soy(s1), sugar(s2) {  }
   } ;
   ...
} ;

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.

How does throw differ from return?

Suppose function f1() calls 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.

Suppose you have a hierarchy of exception classes derived from a base exception class. In what order should you place catch blocks?

You should arrange the catch blocks in the order of most derived class to least derived.

Consider the Grand, Superb, and Magnificent classes defined in this chapter. Suppose pg is a type Grand * pointer assigned the address of an object of one of these three classes and that ps is a type Superb * pointer. What is the difference in how the following two code samples behave?

if (ps = dynamic_cast<Superb *>(pg))
    ps->say();  // sample #1
if (typeid(*pg) == typeid(Superb))
    (Superb *) pg)->say();  // sample #2

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.

How is the static_cast operator different from the dynamic_cast operator?

The dynamic_cast operator only allows upcasting in a class hierarchy, while 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.