Полезная информация




Appendix D

Answers

Day 1

Quiz

1. What is the difference between interpreters and compilers?

Interpreters read through source code and translate a program, turning the programmer's code, or program instructions, directly into actions. Compilers translate source code into an executable program that can be run at a later time.

2. How do you compile the source code with your compiler?


Every compiler is different. Be sure to check the documentation that came with your compiler.

3. What does the linker do?


The linker's job is to tie together your compiled code with the libraries supplied by your compiler vendor and other sources. The linker lets you build your program in pieces and then link together the pieces into one big program.

4. What are the steps in the development cycle?


Edit source code, compile, link, test, repeat.

Exercises

1. Initializes two integer variables and then prints out their sum and their product.

2.
See your compiler manual.

3.
You must put a # symbol before the word include on the first line.

4.
This program prints the words Hello World to the screen, followed by a new line (carriage return).

Day 2

Quiz

1. What is the difference between the compiler and the preprocessor?

Each time you run your compiler, the preprocessor runs first. It reads through your source code and includes the files you've asked for, and performs other housekeeping chores. The preprocessor is discussed in detail on Day 18, "Object-Oriented Analysis and Design."

2. Why is the function main() special?

main()
is called automatically, each time your program is executed.

3. What are the two types of comments, and how do they differ?

C++-style comments are two slashes (//), and they comment out any text until the end of the line. C-style comments come in pairs (/* */), and everything between the matching pairs is commented out. You must be careful to ensure you have matched pairs.

4. Can comments be nested?

Yes, C++-style comments can be nested within C-style comments. You can, in fact, nest C-style comments within C++-style comments, as long as you remember that the C++-style comments end at the end of the line.
5. Can comments be longer than one line?

C-style comments can. If you want to extend C++-style comments to a second line, you must put another set of double slashes (//).

Exercises

1. Write a program that writes I love C++ to the screen.
1: #include <iostream.h>
2:
3: int main()
4: {
5:    cout << "I love C++\n";
6:    return 0;
7: }
2. Write the smallest program that can be compiled, linked, and run.
int main(){}
3. BUG BUSTERS: Enter this program and compile it. Why does it fail? How can you fix it?
1: #include <iostream.h>
2: main()
3: {
4:      cout << Is there a bug here?";
5: }
Line 4 is missing an opening quote for the string.


4.
Fix the bug in Exercise 3 and recompile, link, and run it.
1: #include <iostream.h>
2: main()
3: {
4:      cout << "Is there a bug here?";
5: }

Day 3

Quiz

1. What is the difference between an integral variable and a floating-point variable?

Integer variables are whole numbers; floating-point variables are "reals" and have a "floating" decimal point. Floating-point numbers can be represented using a mantissa and an exponent.

2. What are the differences between an unsigned short int and a long int?

The keyword unsigned means that the integer will hold only positive numbers. On most computers, short integers are 2 bytes and long integers are 4.

3. What are the advantages of using a symbolic constant rather than a literal?

A symbolic constant explains itself; the name of the constant tells what it is for. Also, symbolic constants can be redefined at one location in the source code, rather than the programmer having to edit the code everywhere the literal is used.

4. What are the advantages of using the const keyword rather than #define?

const
variables are "typed;" thus the compiler can check for errors in how they are used. Also, they survive the preprocessor; thus the name is available in the debugger.

5. What makes for a good or bad variable name?

A good variable name tells you what the variable is for; a bad variable name has no information. myAge and PeopleOnTheBus are good variable names, but xjk and prndl are probably less useful.

6. Given this enum, what is the value of Blue?
enum COLOR { WHITE, BLACK = 100, RED, BLUE, GREEN = 300 };
BLUE = 102
7. Which of the following variable names are good, which are bad, and which are invalid?

a. Age

Good

b. !ex
Not legal

c. R79J
Legal, but a bad choice

d. TotalIncome
Good

e. __Invalid
Legal, but a bad choice

Exercises

1. What would be the correct variable type in which to store the following information?

a.
Your age.
Unsigned short integer

b. The area of your backyard.
Unsigned long integer or unsigned float

c. The number of stars in the galaxy.
Unsigned double

d. The average rainfall for the month of January.
Unsigned short integer

2. Create good variable names for this information.

a
. myAge

b. backYardArea

c. StarsInGalaxy

d. averageRainFall

3. Declare a constant for pi as 3.14159.
const float PI = 3.14159;
4. Declare a float variable and initialize it using your pi constant.
float myPi = PI;

Day 4

Quiz

1. What is an expression?

Any statement that returns a value.

2. Is x = 5 + 7 an expression? What is its value?

Yes. 12

3. What is the value of 201 / 4?

50


4. What is the value of 201 % 4?

1


5. If myAge, a, and b are all int variables, what are their values after:
myAge = 39;
a = myAge++;

b = ++myAge;
myAge: 41, a: 39, b: 41
6. What is the value of 8+2*3?
14

7. What is the difference between if(x = 3) and if(x == 3)?

The first one assigns 3 to x and returns true. The second one tests whether x is equal to 3; it returns true if the value of x is equal to 3 and false if it is not.

8. Do the following values evaluate to TRUE or FALSE?

a. 0
FALSE


b. 1

TRUE
c. -1
TRUE
d. x = 0
FALSE
e. x == 0 // assume that x has the value of 0
TRUE

Exercises

1. Write a single if statement that examines two integer variables and changes the larger to the smaller, using only one else clause.
if (x > y)
    x = y;
else          // y > x || y == x
    y = x;
2. Examine the following program. Imagine entering three numbers, and write what output you expect.
1:   #include <iostream.h>
2:   int main()
3:   {
4:        int a, b, c;
5:        cout << "Please enter three numbers\n";
6:        cout << "a: ";
7:        cin >> a;
8:        cout << "\nb: ";
9:        cin >> b;
10:       cout << "\nc: ";
11:       cin >> c;
12:
13:       if (c = (a-b))
14        {
15:            cout << "a: " << a << " minus b: ";
16:            cout << b << " _equals c: " << c;
17:       }
15:       else
16:            cout << "a-b does not equal c: ";
17:     return 0;
18:  }
3. Enter the program from Exercise 2; compile, link, and run it. Enter the numbers 20, 10, and 50. Did you get the output you expected? Why not?

Enter 20, 10, 50.

Get back a: 20 b: 30 c: 10.

Line 13 is assigning, not testing for equality.

4.
Examine this program and anticipate the output:
1:     #include <iostream.h>
2:      int main()
3:      {
4:           int a = 2, b = 2, c;
5:           if (c = (a-b))
6:                cout << "The value of c is: " << c;
7:     return 0;

8:      }
5. Enter, compile, link, and run the program from Exercise 4. What was the output? Why?

Because line 5 is assigning the value of a-b to c, the value of the assignment is a (1) minus b (1), or 0. Because 0 is evaluated as FALSE, the if fails and nothing is printed.

Day 5

Quiz

1. What are the differences between the function prototype and the function defi-nition?

The function prototype declares the function; the definition defines it. The prototype ends with a semicolon; the definition need not. The declaration can include the keyword inline and default values for the parameters; the definition cannot. The declaration need not include names for the parameters; the definition must.

2. Do the names of parameters have to agree in the prototype, definition, and call to the function?


No. All parameters are identified by position, not name.

3. If a function doesn't return a value, how do you declare the function?

Declare the function to return void.

4. If you don't declare a return value, what type of return value is assumed?

Any function that does not explicitly declare a return type returns int.

5. What is a local variable?

A local variable is a variable passed into or declared within a block, typically a function. It is visible only within the block.

6. What is scope?

Scope refers to the visibility and lifetime of local and global variables. Scope is usually established by a set of braces.

7. What is recursion?

Recursion generally refers to the ability of a function to call itself.

8. When should you use global variables?

Global variables are typically used when many functions need access to the same data. Global variables are very rare in C++; once you know how to create static class variables, you will almost never create global variables.

9. What is function overloading?

Function overloading is the ability to write more than one function with the same name, distinguished by the number or type of the parameters.

10. What is polymorphism?

Polymorphism is the ability to treat many objects of differing but related types without regard to their differences. In C++, polymorphism is accomplished by using class derivation and virtual functions.

Exercises

1. Write the prototype for a function named Perimeter, which returns an unsigned long int and which takes two parameters, both unsigned short ints.
unsigned long int Perimeter(unsigned short int, unsigned short int);

2. Write the definition of the function Perimeter as described in Exercise 1. The two parameters represent the length and width of a rectangle and have the function return the perimeter (twice the length plus twice the width).
unsigned long int Perimeter(unsigned short int length, unsigned short int width)

{
  return 2*length + 2*width;
}
3. BUG BUSTERS: What is wrong with the function?
#include <iostream.h>
void myFunc(unsigned short int x);
int main()
{
    unsigned short int x, y;
    y = myFunc(int);
    cout << "x: " << x << " y: " << y << "\n";
return 0;
}

void myFunc(unsigned short int x)
{
    return (4*x);
}
The function is declared to return void and it cannot return a value.

4. BUG BUSTERS: What is wrong with the function?
#include <iostream.h>
int myFunc(unsigned short int x);
int main()
{
    unsigned short int x, y;
    y = myFunc(int);
    cout << "x: " << x << " y: " << y << "\n";
return 0;
}

int myFunc(unsigned short int x)
{
    return (4*x);
}
This function would be fine, but there is a semicolon at the end of the function definition's header.

5. Write a function that takes two unsigned short int arguments and returns the result of dividing the first by the second. Do not do the division if the second number is 0, but do return -1.
short int Divider(unsigned short int valOne, unsigned short int valTwo)
{
    if (valTwo == 0)
          return -1;
    else
          return valOne / valTwo;
}
6. Write a program that asks the user for two numbers and calls the function you wrote in Exercise 5. Print the answer, or print an error message if you get -1.
#include <iostream.h>
typedef unsigned short int USHORT;
typedef unsigned long int ULONG;
short int Divider(
unsigned short int valone,
unsigned short int valtwo);
int main()
{
    USHORT one, two;
    short int answer;
    cout << "Enter two numbers.\n Number one: ";
    cin >> one;
    cout << "Number two: ";
    cin >> two;
    answer = Divider(one, two);
    if (answer > -1)
       cout << "Answer: " << answer;
    else
       cout << "Error, can't divide by zero!";
return 0;
}
7. Write a program that asks for a number and a power. Write a recursive function that takes the number to the power. Thus, if the number is 2 and the power is 4, the function will return 16.
#include <iostream.h>
typedef unsigned short USHORT;
typedef unsigned long ULONG;
ULONG GetPower(USHORT n, USHORT power);
int main()
{
   USHORT number, power;
   ULONG answer;
   cout << "Enter a number: ";
   cin >> number;
   cout << "To what power? ";
   cin >> power;
   answer = GetPower(number,power);
   cout << number << " to the " << power << "th power is " <<
answer << endl;
return 0;
}

ULONG GetPower(USHORT n, USHORT power)
{
    if(power == 1)
     return n;
    else
       return (n * GetPower(n,power-1));
}

Day 6

Quiz

1. What is the dot operator, and what is it used for?

The dot operator is the period (.). It is used to access the members of the class.

2. Which sets aside memory--declaration or definition?

Definitions of variables set aside memory. Declarations of classes don't set aside memory.

3. Is the declaration of a class its interface or its implementation?

The declaration of a class is its interface; it tells clients of the class how to interact with the class. The implementation of the class is the set of member functions stored--usually in a related CPP file.

4. What is the difference between public and private data members?

Public data members can be accessed by clients of the class. Private data members can be accessed only by member functions of the class.

5. Can member functions be private?

Yes. Both member functions and member data can be private.

6. Can member data be public?

Although member data can be public, it is good programming practice to make it private and to provide public accessor functions to the data.

7. If you declare two Cat objects, can they have different values in their itsAge member data?

Yes. Each object of a class has its own data members.

8. Do class declarations end with a semicolon? Do class method definitions?

Declarations end with a semicolon after the closing brace; function definitions do not.

9. What would the header for a Cat function, Meow, that takes no parameters and returns void look like?

The header for a Cat function, Meow(), that takes no parameters and returns void looks like this:
void Cat::Meow()
10. What function is called to initialize a class?

The constructor is called to initialize a class.

Exercises

1. Write the code that declares a class called Employee with these data members: age, yearsOfService, and Salary.
class Employee
{
    int Age;
    int YearsOfService;
    int Salary;
};
2. Rewrite the Employee class to make the data members private, and provide public accessor methods to get and set each of the data members.
class Employee
{
public:
    int GetAge() const;
    void SetAge(int age);
    int GetYearsOfService()const;
    void SetYearsOfService(int years);
    int GetSalary()const;
    void SetSalary(int salary);

private:
    int Age;
    int YearsOfService;
    int Salary;
};
3. Write a program with the Employee class that makes two Employees; sets their age, YearsOfService, and Salary; and prints their values.
main()
{
    Employee John;
    Employee Sally;
    John.SetAge(30);
    John.SetYearsOfService(5);
    John.SetSalary(50000);

    Sally.SetAge(32);
    Sally.SetYearsOfService(8);
    Sally.SetSalary(40000);

    cout << "At AcmeSexist company, John and Sally have the same
job.\n";
    cout << "John is " << John.GetAge() << " years old and he has
been with";
    cout << "the firm for " << John.GetYearsOfService << "
years.\n";
    cout << "John earns $" << John.GetSalary << " dollars per
year.\n\n";
    cout << "Sally, on the other hand is " << Sally.GetAge() << "
years old and has";
    cout << "been with the company " << Sally.GetYearsOfService;
    cout << " years. Yet Sally only makes $" << Sally.GetSalary();
    cout << " dollars per year!  Something here is unfair.";
4. Continuing from Exercise 3, provide a method of Employee that reports how many thousands of dollars the employee earns, rounded to the nearest 1,000.
float Employee:GetRoundedThousands()const
{
    return Salary / 1000;
}
5. Change the Employee class so that you can initialize age, YearsOfService, and Salary when you create the employee.
class Employee
{
public:

    Employee(int age, int yearsOfService, int salary);
    int GetAge()const;
    void SetAge(int age);
    int GetYearsOfService()const;
    void SetYearsOfService(int years);
    int GetSalary()const;
    void SetSalary(int salary);

private:
    int Age;
    int YearsOfService;
    int Salary;
};
6. BUG BUSTERS: What is wrong with the following declaration?
class Square
{
public:
    int Side;
}
Class declarations must end with a semicolon.

7. BUG BUSTERS: Why isn't the following class declaration very useful?
class Cat
{
    int GetAge()const;
private:
    int itsAge;
};
The accessor GetAge() is private. Remember: All class members are private unless you say otherwise.

8. BUG BUSTERS: What three bugs in this code will the compiler find?
class  TV
{
public:
    void SetStation(int Station);
    int GetStation() const;
private:
    int itsStation;
};

main()
{
    TV myTV;
    myTV.itsStation = 9;
    TV.SetStation(10);
    TV myOtherTv(2);
}
You can't access itsStation directly. It is private.
You can't call SetStation() on the class. You can call SetStation() only on objects.
You can't initialize itsStation because there is no matching constructor.

Day 7

Quiz

1. How do I initialize more than one variable in a for loop?

Separate the initializations with commas, such as
for (x = 0, y = 10; x < 100; x++, y++)
2. Why is goto avoided?

goto
jumps in any direction to any arbitrary line of code. This makes for source code that is difficult to understand and therefore difficult to maintain.

3. Is it possible to write a for loop with a body that is never executed?

Yes, if the condition is FALSE after the initialization, the body of the for loop will never execute. Here's an example:
for (int x = 100; x < 100; x++)
4. Is it possible to nest while loops within for loops?

Yes. Any loop can be nested within any other loop.

5. Is it possible to create a loop that never ends? Give an example.

Yes. Following are examples for both a for loop and a while loop:
for(;;)
{
    // This for loop never ends!
}
while(1)
{
    // This while loop never ends!

}
6. What happens if you create a loop that never ends?

Your program hangs, and you usually must reboot the computer.

Exercises

1. What is the value of x when the for loop completes?
for (int x = 0; x < 100; x++)
100
2. Write a nested for loop that prints a 10x10 pattern of 0s.
for (int i = 0; i< 10; i++)
{
    for ( int j = 0; j< 10; j++)
       cout << "0";
    cout << "\n";
}
3. Write a for statement to count from 100 to 200 by 2s.
for (int x = 100; x<=200; x+=2)
4. Write a while loop to count from 100 to 200 by 2s.
int x = 100;
while (x <= 200)
    x+= 2;
5. Write a do...while loop to count from 100 to 200 by 2s.
int x = 100;
do
{
    x+=2;
} while (x <= 200);
6. BUG BUSTERS: What is wrong with this code?
int counter = 0
while (counter < 10)
{ 
    cout << "counter: " << counter;
    counter++;
}
counter is never incremented and the while loop will never terminate.

7. BUG BUSTERS: What is wrong with this code?
for (int counter = 0; counter < 10; counter++);
    cout << counter << "\n";
There is a semicolon after the loop, and the loop does nothing. The programmer may have intended this, but if counter was supposed to print each value, it won't.

8. BUG BUSTERS: What is wrong with this code?
int counter = 100;
while (counter < 10)
{
    cout << "counter now: " << counter;
    counter--;
}
counter is initialized to 100, but the test condition is that if it is less than 10, the test will fail and the body will never be executed. If line 1 were changed to int counter = 5;, the loop would not terminate until it had counted down past the smallest possible int. Because int is signed by default, this would not be what was intended.

9. BUG BUSTERS: What is wrong with this code?
cout << "Enter a number between 0 and 5: ";
cin >> theNumber;
switch (theNumber)
{
   case 0:
         doZero();
   case 1:              // fall through
   case 2:              // fall through
   case 3:              // fall through
   case 4:              // fall through
   case 5: 
         doOneToFive();
         break;
   default:
         doDefault();
         break;
}
Case 0 probably needs a break statement. If it does not, it should be documented with a comment.

Day 8

Quiz

1. What operator is used to determine the address of a variable?

The address of operator (&) is used to determine the address of any variable.

2. What operator is used to find the value stored at an address held in a pointer?

The dereference operator (*) is used to access the value at an address in a pointer.

3. What is a pointer?

A pointer is a variable that holds the address of another variable.

4. What is the difference between the address stored in a pointer and the value at that address?

The address stored in the pointer is the address of another variable. The value stored at that address is any value stored in any variable. The indirection operator (*) returns the value stored at the address, which itself is stored in the pointer.

5. What is the difference between the indirection operator and the address of oper-ator?

The indirection operator returns the value at the address stored in a pointer. The address of operator (&) returns the memory address of the variable.

6. What is the difference between const int * ptrOne and int * const ptrTwo?

The const int * ptrOne declares that ptrOne is a pointer to a constant integer. The integer itself cannot be changed using this pointer.
The int * const ptrTwo declares that ptrTwo is a constant pointer to an integer. Once it is initialized, this pointer cannot be reassigned.

Exercises

1. What do these declarations do?

a.
int * pOne;
b. int vTwo;
c. int * pThree = &vTwo;

a.
int * pOne; declares a pointer to an integer.
b. int vTwo; declares an integer variable.
c. int * pThree = &vTwo; declares a pointer to an integer and initializes it with the address of another variable.

2.
If you have an unsigned short variable named yourAge, how would you declare a pointer to manipulate yourAge?
unsigned short *pAge = &yourAge;
3. Assign the value 50 to the variable yourAge by using the pointer that you declared in Exercise 2.
*pAge = 50;
4. Write a small program that declares an integer and a pointer to integer. Assign the address of the integer to the pointer. Use the pointer to set a value in the integer variable.
int theInteger;
int *pInteger = &theInteger;
*pInteger = 5;
5. BUG BUSTERS: What is wrong with this code?
#include <iostream.h>
int main()
{
     int *pInt;
     *pInt = 9;
     cout << "The value at pInt: " << *pInt;
return 0;
}
pInt should have been initialized. More importantly, because it was not initialized and was not assigned the address of any memory, it points to a random place in memory. Assigning 9 to that random place is a dangerous bug.

6. BUG BUSTERS: What is wrong with this code?
int main()
{
    int SomeVariable = 5;
    cout << "SomeVariable: " << SomeVariable << "\n";
    int *pVar = & SomeVariable;
    pVar = 9;
    cout << "SomeVariable: " << *pVar << "\n";
return 0;
}
Presumably, the programmer meant to assign 9 to the value at pVar. Unfortunately, 9 was assigned to be the value of pVar because the indirection operator (*) was left off. This will lead to disaster if pVar is used to assign a value.

Day 9

Quiz

1. What is the difference between a reference and a pointer?

A reference is an alias, and a pointer is a variable that holds an address. References cannot be null and cannot be assigned to.

2. When must you use a pointer rather than a reference?

When you may need to reassign what is pointed to, or when the pointer may be null.

3. What does new return if there is insufficient memory to make your new object?

A null pointer (0).

4. What is a constant reference?

This is a shorthand way of saying "a reference to a constant object."

5. What is the difference between passing by reference and passing a reference?

Passing by reference means not making a local copy. It can be accomplished by passing a reference or by passing a pointer.

Exercises

1. Write a program that declares an int, a reference to an int, and a pointer to an int. Use the pointer and the reference to manipulate the value in the int.
int main()
{
int varOne;
int& rVar = varOne;
int* pVar = &varOne;
rVar = 5;
*pVar = 7;
return 0;
}
2. Write a program that declares a constant pointer to a constant integer. Initialize the pointer to an integer variable, varOne. Assign 6 to varOne. Use the pointer to assign 7 to varOne. Create a second integer variable, varTwo. Reassign the pointer to varTwo.
int main()
{
   int varOne;
   const int * const pVar = &varOne;
   *pVar = 7;
   int varTwo;
   pVar = &varTwo;
return 0;
}
3. Compile the program in Exercise 2. What produces errors? What produces warnings?
You can't assign a value to a constant object, and you can't reassign a constant pointer.

4. Write a program that produces a stray pointer.
int main()
{
int * pVar;
*pVar = 9;
return 0;
}
5. Fix the program from Exercise 4.
int main()
{
int VarOne;
int * pVar = &varOne;
*pVar = 9;
return 0;
}
6. Write a program that produces a memory leak.
int FuncOne();
int main()
{
   int localVar = FunOne();
   cout << "the value of localVar is: " << localVar;
return 0;
}

int FuncOne()
{
   int * pVar = new int (5);
   return *pVar;
}
7. Fix the program from Exercise 6.
void FuncOne();
int main()
{
   FuncOne();
return 0;
}

void FuncOne()
{
   int * pVar = new int (5);
   cout << "the value of *pVar is: " << *pVar ;
}
8. BUG BUSTERS: What is wrong with this program?
1:     #include <iostream.h>
2:
3:     class CAT
4:     {
5:        public:
6:           CAT(int age) { itsAge = age; }
7:           ~CAT(){}
8:           int GetAge() const { return itsAge;}
9:        private:
10:          int itsAge;
11:    };
12:
13:    CAT & MakeCat(int age);
14:    int main()
15:    {
16:       int age = 7;
17:       CAT Boots = MakeCat(age);
18:       cout << "Boots is " << Boots.GetAge() << " years old\n";
19:     return 0;
20:    }
21:
22:    CAT & MakeCat(int age)
23:    {
24:       CAT * pCat = new CAT(age);
25:       return *pCat;
26:    }
MakeCat returns a reference to the CAT created on the free store. There is no way to free that memory, and this produces a memory leak.

9. Fix the program from Exercise 8.
1:     #include <iostream.h>
2:
3:     class CAT
4:     {
5:        public:
6:           CAT(int age) { itsAge = age; }
7:           ~CAT(){}
8:           int GetAge() const { return itsAge;}
9:        private:
10:          int itsAge;
11:    };
12:
13:    CAT * MakeCat(int age);
14:    int main()
15:    {
16:       int age = 7;
17:       CAT * Boots = MakeCat(age);
18:       cout << "Boots is " << Boots->GetAge() << " years old\n";
19:       delete Boots;
20:     return 0;
21:    }
22:
23:    CAT * MakeCat(int age)
24:    {
25:       return new CAT(age);
26:    }

Day 10

Quiz

1. When you overload member functions, in what ways must they differ?

Overloaded member functions are functions in a class that share a name but differ in the number or type of their parameters.
2. What is the difference between a declaration and a definition?

A definition sets aside memory, but a declaration does not. Almost all declarations are definitions; the major exceptions are class declarations, function prototypes, and typedef statements.

3. When is the copy constructor called?

Whenever a temporary copy of an object is created. This happens every time an object is passed by value.

4. When is the destructor called?

The destructor is called each time an object is destroyed, either because it goes out of scope or because you call delete on a pointer pointing to it.

5. How does the copy constructor differ from the assignment operator (=)?

The assignment operator acts on an existing object; the copy constructor creates a new one.

6. What is the this pointer?

The this pointer is a hidden parameter in every member function that points to the object itself.

7. How do you differentiate between overloading the prefix and postfix increments?

The prefix operator takes no parameters. The postfix operator takes a single int parameter, which is used as a signal to the compiler that this is the postfix variant.

8. Can you overload the operator+ for short integers?

No, you cannot overload any operator for built-in types.

9. Is it legal in C++ to overload operator++ so that it decrements a value in your class?

It is legal, but it is a bad idea. Operators should be overloaded in a way that is likely to be readily understood by anyone reading your code.

10. What return value must conversion operators have in their declaration?

None. Like constructors and destructors, they have no return values.

Exercises

1. Write a SimpleCircle class declaration (only) with one member variable: itsRadius. Include a default constructor, a destructor, and accessor methods for itsRadius.
class SimpleCircle
{
public:
     SimpleCircle();
     ~SimpleCircle();
     void SetRadius(int);
     int GetRadius();
private:
     int itsRadius;
};
2. Using the class you created in Exercise 1, write the implementation of the default constructor, initializing itsRadius with the value 5.
SimpleCircle::SimpleCircle():
itsRadius(5)
{}
3. Using the same class, add a second constructor that takes a value as its parameter and assigns that value to itsRadius.
SimpleCircle::SimpleCircle(int radius):
itsRadius(radius)
{}
4. Create a prefix and postfix increment operator for your SimpleCircle class that increments itsRadius.
const SimpleCircle& SimpleCircle::operator++()
{
     ++(itsRadius);
     return *this;
}

// Operator ++(int) postfix. 
// Fetch then increment
const SimpleCircle SimpleCircle::operator++ (int)
{
// declare local SimpleCircle and initialize to value of *this
    SimpleCircle temp(*this);  
    ++(itsRadius);
    return temp;  
}
5. Change SimpleCircle to store itsRadius on the free store, and fix the existing methods.
class SimpleCircle
{
public:
     SimpleCircle();
     SimpleCircle(int);
     ~SimpleCircle();
     void SetRadius(int);
     int GetRadius();
     const SimpleCircle& operator++();
     const SimpleCircle operator++(int);
private:
     int *itsRadius;
};


SimpleCircle::SimpleCircle()
{itsRadius = new int(5);}

SimpleCircle::SimpleCircle(int radius)
{itsRadius = new int(radius);}

const SimpleCircle& SimpleCircle::operator++()
{
     ++(itsRadius);
     return *this;
}

// Operator ++(int) postfix. 
// Fetch then increment
const SimpleCircle SimpleCircle::operator++ (int)
{
// declare local SimpleCircle and initialize to value of *this
    SimpleCircle temp(*this);  
    ++(itsRadius);
    return temp;  
}
6. Provide a copy constructor for SimpleCircle.
SimpleCircle::SimpleCircle(const SimpleCircle & rhs)
{
     int val = rhs.GetRadius();
     itsRadius = new int(val);
}
7. Provide an operator= for SimpleCircle.
SimpleCircle& SimpleCircle::operator=(const SimpleCircle & rhs)
{
     if (this == &rhs)
          return *this;
     delete itsRadius;
    itsRadius = new int;
    *itsRadius = rhs.GetRadius();
    return *this;
}
8. Write a program that creates two SimpleCircle objects. Use the default constructor on one and instantiate the other with the value 9. Call increment on each and then print their values. Finally, assign the second to the first and print its values.
#include <iostream.h>

class SimpleCircle
{
public:
      // constructors
     SimpleCircle();
     SimpleCircle(int);
     SimpleCircle(const SimpleCircle &);
     ~SimpleCircle() {}

// accessor functions
     void SetRadius(int);
     int GetRadius()const;

// operators
     const SimpleCircle& operator++();
     const SimpleCircle operator++(int);
     SimpleCircle& operator=(const SimpleCircle &);

private:
     int *itsRadius;
};


SimpleCircle::SimpleCircle()
{itsRadius = new int(5);}

SimpleCircle::SimpleCircle(int radius)
{itsRadius = new int(radius);}

SimpleCircle::SimpleCircle(const SimpleCircle & rhs)
{
     int val = rhs.GetRadius();
     itsRadius = new int(val);
}
SimpleCircle& SimpleCircle::operator=(const SimpleCircle & rhs)
{
     if (this == &rhs)
          return *this;
     *itsRadius = rhs.GetRadius();
     return *this;
}

const SimpleCircle& SimpleCircle::operator++()
{
     ++(itsRadius);
     return *this;
}

// Operator ++(int) postfix. 
// Fetch then increment
const SimpleCircle SimpleCircle::operator++ (int)
{
// declare local SimpleCircle and initialize to value of *this
    SimpleCircle temp(*this);  
    ++(itsRadius);
    return temp;  
}
int SimpleCircle::GetRadius() const
{
     return *itsRadius;
}
int main()
{
     SimpleCircle CircleOne, CircleTwo(9);
     CircleOne++;
     ++CircleTwo;
     cout << "CircleOne: " << CircleOne.GetRadius() << endl;
     cout << "CircleTwo: " << CircleTwo.GetRadius() << endl;
     CircleOne = CircleTwo;
     cout << "CircleOne: " << CircleOne.GetRadius() << endl;
     cout << "CircleTwo: " << CircleTwo.GetRadius() << endl;
return 0;
}
9. BUG BUSTERS: What is wrong with this implementation of the assignment operator?
SQUARE SQUARE ::operator=(const SQUARE & rhs)
{
      itsSide = new int;
      *itsSide = rhs.GetSide();
      return *this;
}
You must check to see whether rhs equals this, or the call to a = a will crash your program.

10. BUG BUSTERS: What is wrong with this implementation of operator+?
VeryShort  VeryShort::operator+ (const VeryShort& rhs)
{
   itsVal += rhs.GetItsVal();
   return *this;
}
This operator+ is changing the value in one of the operands, rather than creating a new VeryShort object with the sum. The right way to do this is as follows:
VeryShort  VeryShort::operator+ (const VeryShort& rhs)
{
   return VeryShort(itsVal + rhs.GetItsVal());
}

Day 11

Quiz

1. What are the first and last elements in SomeArray[25]?

SomeArray[0]
, SomeArray[24]

2. How do you declare a multidimensional array?

Write a set of subscripts for each dimension. For example, SomeArray[2][3][2] is a three-dimensional array. The first dimension has two elements, the second has three, and
the third has two.

3. Initialize the members of the array in Question 2.
SomeArray[2][3][2] = { { {1,2},{3,4},{5,6} } , { {7,8},{9,10},{11,12} } };
4. How many elements are in the array SomeArray[10][5][20]?

10x5x20=1,000

5. What is the maximum number of elements that you can add to a linked list?

There is no fixed maximum. It depends on how much memory you have available.

6. Can you use subscript notation on a linked list?

You can use subscript notation on a linked list only by writing your own class to contain the linked list and overloading the subscript operator.

7. What is the last character in the string "Brad is a nice guy"?

The null character.

Exercises

1. Declare a two-dimensional array that represents a tic-tac-toe game board.
int GameBoard[3][3];
2. Write the code that initializes all the elements in the array you created in Exercise 1 to the value 0.
int GameBoard[3][3] = { {0,0,0},{0,0,0},{0,0,0} }
3. Write the declaration for a Node class that holds unsigned short integers.
 class Node
 {
 public:
    Node ();
    Node (int);
    ~Node();
    void SetNext(Node * node) { itsNext = node; }
    Node * GetNext() const { return itsNext; }
    int GetVal() const { return itsVal; }
    void Insert(Node *);
    void Display();
 private:
    int itsVal;
    Node * itsNext;
 };
4. BUG BUSTERS: What is wrong with this code fragment?
unsigned short SomeArray[5][4];
for (int i = 0; i<4; i++)
     for (int j = 0; j<5; j++)
          SomeArray[i][j] = i+j;
The array is 5 elements by 4 elements, but the code initializes 4x5.

5.
BUG BUSTERS: What is wrong with this code fragment?
unsigned short SomeArray[5][4];
for (int i = 0; i<=5; i++)
     for (int j = 0; j<=4; j++)
          SomeArray[i][j] = 0;
You wanted to write i<5, but you wrote i<=5 instead. The code will run when i == 5 and j == 4, but there is no such element as SomeArray[5][4].

Day 12

Quiz

1. What is a v-table?

A v-table, or virtual function table, is a common way for compilers to manage virtual functions in C++. The table keeps a list of the addresses of all the virtual functions and, depending on the runtime type of the object pointed to, invokes the right function.

2. What is a virtual destructor?

A destructor of any class can be declared to be virtual. When the pointer is deleted, the runtime type of the object will be assessed and the correct derived destructor invoked.

3. How do you show the declaration of a virtual constructor?

There are no virtual constructors.

4. How can you create a virtual copy constructor?

By creating a virtual method in your class, which itself calls the copy constructor.

5. How do you invoke a base member function from a derived class in which you've overridden that function?
Base::FunctionName();
6. How do you invoke a base member function from a derived class in which you have not
overridden that function?
FunctionName();
7. If a base class declares a function to be virtual, and a derived class does not use the term virtual when overriding that class, is it still virtual when inherited by a third-generation class?

Yes, the virtuality is inherited and cannot be turned off.

8. What is the protected keyword used for?

protected
members are accessible to the member functions of derived objects.

Exercises

1. Show the declaration of a virtual function taking an integer parameter and returning void.
virtual void SomeFunction(int);
2. Show the declaration of a class Square, which derives from Rectangle, which in turn derives from Shape.
class Square : public Rectangle
{};
3. If, in Exercise 2, Shape takes no parameters, Rectangle takes two (length and width), and Square takes only one (length), show the constructor initialization for Square.
Square::Square(int length):
     Rectangle(length, length){}
4. Write a virtual copy constructor for the class Square (from the preceding question).
class Square
      {
         public:
         // ...
         virtual Square * clone() const { return new Square(*this); }
       // ...
     };
5. BUG BUSTERS: What is wrong with this code snippet?
void SomeFunction (Shape);
Shape * pRect = new Rectangle;
SomeFunction(*pRect);
Perhaps nothing. SomeFunction expects a Shape object. You've passed it a Rectangle "sliced" down to a Shape. As long as you don't need any of the Rectangle parts, this will be fine. If you do need the Rectangle parts, you'll need to change SomeFunction to take a pointer or a reference to a Shape.

6.
BUG BUSTERS: What is wrong with this code snippet?
class Shape()
{
public:
     Shape();
     virtual ~Shape();
     virtual Shape(const Shape&);
};
You can't declare a copy constructor to be virtual.

Day 13

Quiz

1. What is a down cast?

A down cast (also called "casting down") is a declaration that a pointer to a base class is to be treated as a pointer to a derived class.

2. What is the v-ptr?

The v-ptr, or virtual-function pointer, is an implementation detail of virtual functions. Each object in a class with virtual functions has a v-ptr, which points to the virtual function table for that class.

3. If a round rectangle has straight edges and rounded corners, your RoundRect class inherits both from Rectangle and from Circle, and they in turn both inherit from Shape, how many Shapes are created when you create a RoundRect?

If neither class inherits using the keyword virtual, two Shapes are created: one for Rectangle and one for Shape. If the keyword virtual is used for both classes, only one shared Shape is created.

4. If Horse and Bird inherit virtual public from Animal, do their constructors initialize the Animal constructor? If Pegasus inherits from both Horse and Bird, how does it initialize Animal's constructor?

Both Horse and Bird initialize their base class, Animal, in their constructors. Pegasus does as well, and when a Pegasus is created, the Horse and Bird initializations of Animal are ignored.

5. Declare a class Vehicle and make it an abstract data type.
class Vehicle
{
     virtual void Move() = 0;
}
6. If a base class is an ADT, and it has three pure virtual functions, how many of these functions must be overridden in its derived classes?

None must be overridden unless you want to make the class non-abstract, in which case all three must be overridden.

Exercises

1. Show the declaration for a class JetPlane, which inherits from Rocket and Airplane.
class JetPlane : public Rocket, public Airplane
2. Show the declaration for 747, which inherits from the JetPlane class described in Exercise 1.
class 747 : public JetPlane
3. Show the declarations for the classes Car and Bus, which each derive from the class Vehicle. Make Vehicle an ADT with two pure virtual functions. Make Car and Bus not be ADTs.
class Vehicle
{
     virtual void Move() = 0;
     virtual void Haul() = 0;
};

class Car : public Vehicle
{
     virtual void Move();
     virtual void Haul();
};

class Bus : public Vehicle
{
     virtual void Move();
     virtual void Haul();
};
4. Modify the program in Exercise 1 so that Car is an ADT, and derive SportsCar and Coupe from Car. In the Car class, provide an implementation for one of the pure virtual functions in Vehicle and make it non-pure.
class Vehicle
{
     virtual void Move() = 0;
     virtual void Haul() = 0;
};

class Car : public Vehicle
{
     virtual void Move();
};

class Bus : public Vehicle
{
     virtual void Move();
     virtual void Haul();
};

class SportsCar : public Car
{
     virtual void Haul();
};

class Coupe : public Car
{
     virtual void Haul();
};

Day 14

Quiz

1. Can static member variables be private?

Yes. They are member variables, and their access can be controlled like any other. If they are private, they can be accessed only by using member functions or, more commonly, static member functions.

2. Show the declaration for a static member variable.
static int itsStatic;
3. Show the declaration for a static function pointer.
static int SomeFunction();
4. Show the declaration for a pointer to function returning long and taking an integer parameter.
long (* function)(int);
5. Modify the pointer in Exercise 4 to be a pointer to member function of class Car
long ( Car::*function)(int);
6. Show the declaration for an array of 10 pointers as defined in Exercise 5.
(long ( Car::*function)(int) theArray [10];

Exercises

1. Write a short program declaring a class with one member variable and one static member variable. Have the constructor initialize the member variable and increment the static member variable. Have the destructor decrement the member variable.
1:     class myClass
2:     {
3:     public:
4:        myClass();
5:        ~myClass();
6:     private:
7:        int itsMember;
8:        static int itsStatic;
9:     };
10:
11:    myClass::myClass():
12:     itsMember(1)
13:    {
14:       itsStatic++;
15:    }
16:
17:    myClass::~myClass()
18:    {
19:       itsStatic--;
20:    }
21:
22:    int myClass::itsStatic = 0;
23:
24:    int main()
25:    {}
2. Using the program from Exercise 1, write a short driver program that makes three objects and then displays their member variables and the static member variable. Then destroy each object and show the effect on the static member variable.
1:     #include <iostream.h>
2:
3:     class myClass
4:     {
5:     public:
6:        myClass();
7:        ~myClass();
8:        void ShowMember();
9:        void ShowStatic();
10:    private:
11:       int itsMember;
12:       static int itsStatic;
13:    };
14:
15:    myClass::myClass():
16:     itsMember(1)
17:    {
18:       itsStatic++;
19:    }
20:
21:    myClass::~myClass()
22:    {
23:       itsStatic--;
24:       cout << "In destructor. ItsStatic: " << itsStatic << endl;
25:    }
26:
27:    void myClass::ShowMember()
28:    {
29:       cout << "itsMember: " << itsMember << endl;
30:    }
31:
32:    void myClass::ShowStatic()
33:    {
34:       cout << "itsStatic: " << itsStatic << endl;
35:    }
36:    int myClass::itsStatic = 0;
37:
38:    int main()
39:    {
40:       myClass obj1;
41:       obj1.ShowMember();
42:       obj1.ShowStatic();
43:
44:       myClass obj2;
45:       obj2.ShowMember();
46:       obj2.ShowStatic();
47:
48:       myClass obj3;
49:       obj3.ShowMember();
50:       obj3.ShowStatic();
51:     return 0;
52:    }
3. Modify the program from Exercise 2 to use a static member function to access the static member variable. Make the static member variable private.
1:     #include <iostream.h>
2:
3:     class myClass
4:     {
5:     public:
6:        myClass();
7:        ~myClass();
8:        void ShowMember();
9:        static int GetStatic();
10:    private:
11:       int itsMember;
12:       static int itsStatic;
13:    };
14:
15:    myClass::myClass():
16:     itsMember(1)
17:    {
18:       itsStatic++;
19:    }
20:
21:    myClass::~myClass()
22:    {
23:       itsStatic--;
24:       cout << "In destructor. ItsStatic: " << itsStatic << endl;
25:    }
26:
27:    void myClass::ShowMember()
28:    {
29:       cout << "itsMember: " << itsMember << endl;
30:    }
31:
32:    int myClass::itsStatic = 0;
33:
34:    void myClass::GetStatic()
35:    {
36:       return itsStatic;
37:    }
38:
39:    int main()
40:    {
41:       myClass obj1;
42:       obj1.ShowMember();
43:       cout << "Static: " << myClass::GetStatic() << endl;
44:
45:       myClass obj2;
46:       obj2.ShowMember();
47:       cout << "Static: " << myClass::GetStatic() << endl;
48:
49:       myClass obj3;
50:       obj3.ShowMember();
51:       cout << "Static: " << myClass::GetStatic() << endl;
52:     return 0;
53:    }
4. Write a pointer to a member function to access the non-static member data in the program in Exercise 3, and use that pointer to print the value of that data.
1:     #include <iostream.h>
2:
3:     class myClass
4:     {
5:     public:
6:        myClass();
7:        ~myClass();
8:        void ShowMember();
9:        static int GetStatic();
10:    private:
11:       int itsMember;
12:       static int itsStatic;
13:    };
14:
15:    myClass::myClass():
16:     itsMember(1)
17:    {
18:       itsStatic++;
19:    }
20:
21:    myClass::~myClass()
22:    {
23:       itsStatic--;
24:       cout << "In destructor. ItsStatic: " << itsStatic << endl;
25:    }
26:
27:    void myClass::ShowMember()
28:    {
29:       cout << "itsMember: " << itsMember << endl;
30:    }
31:
32:    int myClass::itsStatic = 0;
33:
34:    int myClass::GetStatic()
35:    {
36:       return itsStatic;
37:    }
38:
39:    int main()
40:    {
41:       void (myClass::*PMF) ();
42:
43:       PMF=myClass::ShowMember;
44:
45:       myClass obj1;
46:       (obj1.*PMF)();
47:       cout << "Static: " << myClass::GetStatic() << endl;
48:
49:       myClass obj2;
50:       (obj2.*PMF)();
51:       cout << "Static: " << myClass::GetStatic() << endl;
52:
53:       myClass obj3;
54:       (obj3.*PMF)();
55:       cout << "Static: " << myClass::GetStatic() << endl;
56:     return 0;
57:    }
5. Add two more member variables to the class from the previous questions. Add accessor functions that get the value of this data and give all the member functions the same return values and signatures. Use the pointer to the member function to access these functions.
1:     #include <iostream.h>
2:
3:     class myClass
4:     {
5:     public:
6:        myClass();
7:        ~myClass();
8:        void ShowMember();
9:        void ShowSecond();
10:       void ShowThird();
11:       static int GetStatic();
12:    private:
13:       int itsMember;
14:       int itsSecond;
15:       int itsThird;
16:       static int itsStatic;
17:    };
18:
19:    myClass::myClass():
20:     itsMember(1),
21:     itsSecond(2),
22:     itsThird(3)
23:    {
24:       itsStatic++;
25:    }
26:
27:    myClass::~myClass()
28:    {
29:       itsStatic--;
30:       cout << "In destructor. ItsStatic: " << itsStatic << endl;
31:    }
32:
33:    void myClass::ShowMember()
34:    {
35:       cout << "itsMember: " << itsMember << endl;
36:    }
37:
38:    void myClass::ShowSecond()
39:    {
40:       cout << "itsSecond: " << itsSecond << endl;
41:    }
42:
43:    void myClass::ShowThird()
44:    {
45:       cout << "itsThird: " << itsThird << endl;
46:    }
47:    int myClass::itsStatic = 0;
48:
49:    int myClass::GetStatic()
50:    {
51:       return itsStatic;
52:    }
53:
54:    int main()
55:    {
56:       void (myClass::*PMF) ();
57:
58:       myClass obj1;
59:       PMF=myClass::ShowMember;
60:       (obj1.*PMF)();
61:       PMF=myClass::ShowSecond;
62:       (obj1.*PMF)();
63:       PMF=myClass::ShowThird;
64:       (obj1.*PMF)();
65:       cout << "Static: " << myClass::GetStatic() << endl;
66:
67:       myClass obj2;
68:       PMF=myClass::ShowMember;
69:       (obj2.*PMF)();
70:       PMF=myClass::ShowSecond;
71:       (obj2.*PMF)();
72:       PMF=myClass::ShowThird;
73:       (obj2.*PMF)();
74:       cout << "Static: " << myClass::GetStatic() << endl;
75:
76:       myClass obj3;
77:       PMF=myClass::ShowMember;
78:       (obj3.*PMF)();
79:       PMF=myClass::ShowSecond;
80:       (obj3.*PMF)();
81:       PMF=myClass::ShowThird;
82:       (obj3.*PMF)();
83:       cout << "Static: " << myClass::GetStatic() << endl;
84:     return 0;
85:    }

Day 15

Quiz

1. How do you establish an is-a relationship?

With public inheritance.

2. How do you establish a has-a relationship?

With containment; that is, one class has a member that is an object of another type.

3. What is the difference between containment and delegation?

Containment describes the idea of one class having a data member that is an object of another type. Delegation expresses the idea that one class uses another class to accomplish a task or goal. Delegation is usually accomplished by containment.

4. What is the difference between delegation and implemented-in-terms-of?

Delegation expresses the idea that one class uses another class to accomplish a task or goal. Implemented-in-terms-of expresses the idea of inheriting implementation from another class.

5. What is a friend function?

A friend function is a function declared to have access to the protected and private members of your
class.

6. What is a friend class?

A friend class is a class declared so that all its member functions are friend functions of your class.

7. If Dog is a friend of Boy, is Boy a friend of Dog?

No, friendship is not commutative.

8. If Dog is a friend of Boy, and Terrier derives from Dog, is Terrier a friend of Boy?

No, friendship is not inherited.

9. If Dog is a friend of Boy and Boy is a friend of House, is Dog a friend of House?

No, friendship is not associative.

10. Where must the declaration of a friend function appear?

Anywhere within the class declaration. It makes no difference whether you put the declaration within the public:, protected:, or private: access areas.

Exercises

1. Show the declaration of a class Animal that contains a data member that is a String object.
class Animal:
{
private:
   String itsName;
};
2. Show the declaration of a class BoundedArray that is an array.
class boundedArray : public Array
{
//...
}
3. Show the declaration of a class Set that is declared in terms of an array.
class Set : private Array
{
// ...
}
4. Modify Listing 15.1 to provide the String class with an extraction operator (>>).
1:        #include <iostream.h>
2:        #include <string.h>
3:
4:        class String
5:        {
6:           public:
7:              // constructors
8:              String();
9:               String(const char *const);
10:              String(const String &);
11:             ~String();
12:
13:             // overloaded operators
14:             char & operator[](int offset);
15:             char operator[](int offset) const;
16:             String operator+(const String&);
17:             void operator+=(const String&);
18:             String & operator= (const String &);
19:             friend ostream& operator<<
20:                 ( ostream&   _theStream,String& theString);
21:             friend istream& operator>>
22:                ( istream& _theStream,String& theString);
23:             // General accessors
24:             int GetLen()const { return itsLen; }
25:             const char * GetString() const { return itsString; }
26:             // static int ConstructorCount;
27:
28:          private:
29:             String (int);         // private constructor
30:             char * itsString;
31:             unsigned short itsLen;
32:
33       };
34:
35:       ostream& operator<<( ostream& theStream,String& theString)
36:       {
37:           theStream << theString.GetString();
38:           return theStream;
39:       }
40:
41:       istream& operator>>( istream& theStream,String& theString)
42:       {
43:           theStream >> theString.GetString();
44:           return theStream;
45:       }
46:
47:       int main()
48:       {
49:          String theString("Hello world.");
50:          cout << theString;
51:     return 0;
52:       }
5. BUG BUSTERS: What is wrong with this program?
1:     #include <iostream.h>
2:
3:     class Animal;
4:
5:     void setValue(Animal& , int);
6:
7:
8:     class Animal
9:     {
10:    public:
11:       int GetWeight()const { return itsWeight; }
12:       int GetAge() const { return itsAge; }
13:    private:
14:       int itsWeight;
15:       int itsAge;
16:    };
17:
18:    void setValue(Animal& theAnimal, int theWeight)
19:    {
20:       friend class Animal;
21:       theAnimal.itsWeight = theWeight;
22:    }
23:
24:    int main()
25:    {
26:       Animal peppy;
27:       setValue(peppy,5);
28:     return 0;
29:    }
You can't put the friend declaration into the function. You must declare the function to be a friend in the class.

6. Fix the listing in Exercise 5 so that it will compile.
1:     #include <iostream.h>
2:
3:     class Animal;
4:
5:     void setValue(Animal& , int);
6:
7:
8:     class Animal
9:     {
10:    public:
11:       friend void setValue(Animal&, int);
12:       int GetWeight()const { return itsWeight; }
13:       int GetAge() const { return itsAge; }
14:    private:
15:       int itsWeight;
16:       int itsAge;
17:    };
18:
19:    void setValue(Animal& theAnimal, int theWeight)
20:    {
21:       theAnimal.itsWeight = theWeight;
22:    }
23:
24:    int main()
25:    {
26:       Animal peppy;
27:       setValue(peppy,5);
28:     return 0;
29:    }
7. BUG BUSTERS: What is wrong with this code?
1:     #include <iostream.h>
2:
3:     class Animal;
4:
5:     void setValue(Animal& , int);
6:     void setValue(Animal& ,int,int);
7:
8:     class Animal
9:     {
10:    friend void setValue(Animal& ,int); // here's the change!
11:    private:
12:       int itsWeight;
13:       int itsAge;
14:    };
15:
16:    void setValue(Animal& theAnimal, int theWeight)
17:    {
18:        theAnimal.itsWeight = theWeight;
19:    }
20:
21:
22:    void setValue(Animal& theAnimal, int theWeight, int theAge)
23:    {
24:       theAnimal.itsWeight = theWeight;
25:       theAnimal.itsAge = theAge;
26:    }
27:
28:    int main()
29:    {
30:       Animal peppy;
31:       setValue(peppy,5);
32:       setValue(peppy,7,9);
33:     return 0;
34:    }
The function setValue(Animal&,int) was declared to be a friend, but the overloaded function setValue(Animal&,int,int) was not declared to be a friend.

8. Fix Exercise 7 so it compiles.
1:     #include <iostream.h>
2:
3:     class Animal;
4:
5:     void setValue(Animal& , int);
6:     void setValue(Animal& ,int,int); // here's the change!
7:
8:     class Animal
9:     {
10:    friend void setValue(Animal& ,int);
11:    friend void setValue(Animal& ,int,int);
12:    private:
13:       int itsWeight;
14:       int itsAge;
15:    };
16:
17:    void setValue(Animal& theAnimal, int theWeight)
18:    {
19:        theAnimal.itsWeight = theWeight;
20:    }
21:
22:
23:    void setValue(Animal& theAnimal, int theWeight, int theAge)
24:    {
25:       theAnimal.itsWeight = theWeight;
26:       theAnimal.itsAge = theAge;
27:    }
28:
29:    int main()
30:    {
31:       Animal peppy;
32:       setValue(peppy,5);
33:       setValue(peppy,7,9);
34:     return 0;
35:    }

Day 16

Quiz

1. What is the insertion operator and what does it do?

The insertion operator (<<) is a member operator of the ostream object and is used for writing to the output device.

2. What is the extraction operator and what does it do?

The extraction operator (>>) is a member operator of the istream object and is used for writing to your program's variables.

3. What are the three forms of cin.get() and what are their differences?

The first form of get() is without parameters. This returns the value of the character found, and will return EOF (end of file) if the end of the file is reached.
The second form of cin.get() takes a character reference as its parameter; that character is filled with the next character in the input stream. The return value is an iostream object.
The third form of cin.get() takes an array, a maximum number of characters to get, and a terminating character. This form of get() fills the array with up to one fewer characters than the maximum (appending null) unless it reads the terminating character, in which case it immediately
writes a null and leaves the terminating character in the buffer.

4. What is the difference between cin.read() and cin.getline()?

cin.read()
is used for reading binary data structures.
getline() is used to read from the istream's buffer.

5. What is the default width for ouputting a long integer using the insertion operator?

Wide enough to display the entire number.

6. What is the return value of the insertion operator?

A reference to an istream object.

7. What parameter does the constructor to an ofstream object take?

The filename to be opened.

8. What does the ios::ate argument do?

ios::ate
places you at the end of the file, but you can write data anywhere in the file.

Exercises

1. Write a program that writes to the four standard iostream objects: cin, cout, cerr, and clog.
1:     #include <iostream.h>
2:     int main()
3:     {
4:        int x;
5:        cout << "Enter a number: ";
6:        cin >> x;
7:        cout << "You entered: " << x << endl;
8:        cerr << "Uh oh, this to cerr!" << endl;
9:        clog << "Uh oh, this to clog!" << endl;
10:     return 0;
11:    }
2. Write a program that prompts the user to enter her full name and then displays it on the screen.
1:     #include <iostream.h>
2:     int main()
3:     {
4:        char name[80];
5:        cout << "Enter your full name: ";
6:        cin.getline(name,80);
7:        cout << "\nYou entered: " << name << endl;
8:     return 0;
9:     }
3. Rewrite Listing 16.9 to do the same thing, but without using putback() or ignore().
1:      // Listing
2:      #include <iostream.h>
3:      
4:      int main()
5:      {
6:         char ch;
7:         cout << "enter a phrase: ";
8:         while ( cin.get(ch) )
9:         {
10:           switch (ch)
11:           {
12:             case `!':
13:                cout << `$';
14:                break;
15:             case `#':
16:                break;
17:             default:
18:                cout << ch;
19:                break;
20:          }
21:        }
22:     return 0;
23:     }
4. Write a program that takes a filename as a parameter and opens the file for reading. Read every character of the file and display only the letters and punctuation to the screen. (Ignore all non-printing characters.) Then close the file and exit.
1:     #include <fstream.h>
2:     enum BOOL { FALSE, TRUE };
3:     
4:     int main(int argc, char**argv)   // returns 1 on error
5:     {
6:     
7:        if (argc != 2)
8:        {
9:           cout << "Usage: argv[0] <infile>\n";
10:          return(1);
11:       }
12:    
13:    // open the input stream
14:       ifstream fin (argv[1],ios::binary);
15:       if (!fin)
16:       {
17:          cout << "Unable to open " << argv[1] << " for reading.\n";
18:          return(1);
19:       }
20:    
21:       char ch;
22:       while ( fin.get(ch))
23:          if ((ch > 32 && ch < 127) || ch == `\n' || ch == `\t')
24:             cout << ch;
25:       fin.close();
26:    }
5. Write a program that displays its command-line arguments in reverse order and does not display the program name.
1:     #include <fstream.h>
2:     
3:     int main(int argc, char**argv)   // returns 1 on error
4:     {
5:        for (int ctr = argc; ctr ; ctr--)
6:          cout << argv[ctr] << " ";
7:     }

Day 17

Quiz

1. What is an inclusion guard?

Inclusion guards are used to protect a header file from being included into a program more than once.

2. How do you instruct your compiler to print the contents of the intermediate file showing the effects of the preprocessor?

This quiz question must be answered by you, depending on the compiler you are using.

3. What is the difference between #define debug 0 and #undef debug?

#define debug 0
defines the term debug to equal 0 (zero). Everywhere the word debug is found, the character 0 will be substituted. #undef debug removes any definition of debug; when the word debug is found in the file, it will be left unchanged.

4. Name four predefined macros.

__DATE__
, __TIME__, __FILE__, __LINE__

5. Why can't you call invariants() as the first line of your constructor?

The job of your constructor is to create the object. The class invariants cannot and should not exist before the object is fully created, so any meaningful use of invariants() will return false until the constructor is finished.

Exercises

1. Write the inclusion guard statements for the header file STRING.H.
#ifndef STRING_H
#define STRING_H
...
#endif
2. Write an assert() macro that prints an error message and the file and line number if debug level is 2, prints just a message (without file and line number) if the level is 1, and does nothing if the level is 0.
1:     #include <iostream.h>
2:     
3:     #ifndef DEBUG
4:     #define ASSERT(x)
5:     #elif DEBUG == 1
6:     #define ASSERT(x) \
7:       if (! (x)) \
8:       { \
9:          cout << "ERROR!! Assert " << #x << " failed\n"; \
10:                 }
11:    #elif DEBUG == 2
12:    #define ASSERT(x) \
13:      if (! (x) ) \
14:      { \
15:       cout << "ERROR!! Assert " << #x << " failed\n"; \
16:      cout << " on line " << __LINE__  << "\n"; \
17:       cout << " in file " << __FILE__ << "\n";  \
18:  }
19:    #endif
3. Write a macro DPrint that tests whether debug is defined, and if it is, prints the value passed in as a parameter.
#ifndef DEBUG
#define DPRINT(string)
#else
#define DPRINT(STRING) cout << #STRING ;
#endif
4. Write a function that prints an error message. The function should print the line number and filename where the error occurred. Note that the line number and filename are passed in to this function.
1:     #include <iostream.h>
2:      
3:       void ErrorFunc(
4:          int LineNumber, 
5:          const char * FileName)
6:      {
7:          cout << "An error occurred in file ";
8:           cout << FileName;
9:           cout << " at line " 
10:          cout << LineNumber << endl;
11:     }
5. How would you call the preceding error function?
1:      // driver program to exercise ErrorFunc
2:      int main()
3:      {
4:           cout << "An error occurs on next line!";
5:           ErrorFunc(__LINE__, __FILE__);
6:     return 0;
7:      }
Note that the __LINE__ and __FILE__ macros are used at the point of the error, and not in the error function. If you used them in the error function, they would report the line and file for the error function itself.

6.
Write an assert() macro that uses the error function from Exercise 4, and write a driver program that calls that assert() macro.
1:     #include <iostream.h>
2:      
3:      #define DEBUG // turn error handling on
4:      
5:      #ifndef DEBUG
6:      #define ASSERT(x)
7:      #else
8:      #define ASSERT(X) \
9:         if (! (X)) \
10:         {   \
11:            ErrorFunc(__LINE__, __FILE__); \
12:         }
13:      #endif
14:      
15:      void ErrorFunc(int LineNumber, const char * FileName)
16:      {
17:           cout << "An error occurred in file ";
18:           cout << FileName;
19:           cout << " at line ";
20:           cout << LineNumber << endl;
21:      }
22:      
23:      // driver program to exercise ErrorFunc
24:      int main()
25:      {
26:         int x = 5;
27:         ASSERT(x >= 5);  // no error
28:         x = 3;
29:         ASSERT(x >= 5); // error!
30:     return 0;
31:      }
Note that in this case, the __LINE__ and __FILE__ macros can be called in the assert() macro and will still give the correct line (line 29). This is because the assert() macro is expanded in place, where it is called. Therefore, this program is evaluated exactly as if main() were written as
1:      // driver program to exercise ErrorFunc
2:      int main()
3:      {
4:         int x = 5;
5:         if (! (x >= 5)) {ErrorFunc(__LINE__, __FILE__);}
6:         x = 3;
7:         if (! (x >= 5)) {ErrorFunc(__LINE__, __FILE__);}
8:     return 0;
9:     }

Day 18

Quiz

1. What is the difference between object-oriented programming and procedural programming?

Procedural programming focuses on functions separate from data. Object-oriented programming ties data and functionality together into objects, and focuses on the interaction among the objects.

2. To what does "event-driven" refer?

Event-driven programs are distinguished by the fact that action is taken only in response to some form of (usually external) simulation, such as a user's keyboard or mouse input.

3. What are the stages in the development cycle?

Typically, the development cycle includes analysis, design, coding, testing, programming, and interaction and feedback among these stages.

4. What is a rooted hierarchy?

A rooted hierarchy is one in which all the classes in the program derive directly or indirectly from a single base class.

5. What is a driver program?

A driver program is simply a function that is designed to exercise whatever objects and functions you are currently programming.

6. What is encapsulation?

Encapsulation refers to the (desirable) trait of bringing together in one class all the data and functionality of one discrete entity.

Exercises

1. Suppose you had to simulate the intersection of Massachusetts Avenue and Vassar Street--two typical two-lane roads with traffic lights and crosswalks. The purpose of the simulation is to determine whether the timing of the traffic signal allows for a smooth flow of traffic.

What kinds of objects should be modeled in the simulation? What should be the classes defined for the simulation?

Cars, motorcycles, trucks, bicycles, pedestrians, and emergency vehicles all use the intersection. In addition, there is a traffic signal with Walk/Don't Walk lights.

Should the road surface be included in the simulation?

Certainly, road quality can have an effect on the traffic, but for a first design, it may be simpler to leave this consideration aside. The first object is probably the intersection itself. Perhaps the intersection object maintains lists of cars waiting to pass through the signal in each direction, as well as lists of people waiting to cross at the crosswalks. It will need methods to choose which and how many cars and people go through the intersection.

There will be only one intersection, so you may want to consider how you will ensure that only one object is instantiated (hint: think about static methods and protected access).

People and cars are both clients of the intersection. They share a number of characteristics: they can appear at any time, there can be any number of them, and they both wait at the signal (although in different lines). This suggests that you will want to consider a common base class for pedestrians and cars.

The classes would therefore include
class Entity;   // a client of the intersection

// the root of all cars, trucks, bicycles and emergency vehicles.
class Vehicle : Entity ...;         

// the root of all People
class Pedestrian : Entity...;     

class Car : public Vehicle...;
class Truck : public Vehicle...;
class Motorcycle : public Vehicle...;
class Bicycle : public Vehicle...;
class Emergency_Vehicle : public Vehicle...;

// contains lists of cars and people waiting to pass

class Intersection;          
2. Suppose the intersections from Exercise 1 were in a suburb of Boston, which has arguably the unfriendliest streets in the United States. At any time, there are three kinds of Boston drivers:

Locals, who continue to drive through intersections after the light turns red

Tourists, who drive slowly and cautiously (in a rental car, typically)

Taxis, which have a wide variation of driving patterns, depending on the kinds of passengers in the cabs

Also, Boston has two kinds of pedestrians:

Locals, who cross the street whenever they feel like it and seldom use the crosswalk buttons

Tourists, who always use the crosswalk buttons and only cross when the Walk/Don't Walk light permits.

Finally, Boston has bicyclists who never pay attention to stoplights

How do these considerations change the model?

A reasonable start on this would be to create derived objects that model the refinements suggested by the problem:
class Local_Car : public Car...;
          class Tourist_Car : public Car...;
          class Taxi : public Car...;
          class Local_Pedestrian : public
Pedestrian...;
          class Tourist_Pedestrian : public
Pedestrian...;
          class Boston_Bicycle : public Bicycle...;
By using virtual methods, each class can modify the generic behavior to meet its own specifications. For example, the Boston driver can react to a red light differently than a tourist does, while still inheriting the generic behaviors that continue to apply.

3. You are asked to design a group scheduler. The software allows you to arrange meetings among individuals or groups, and to reserve a limited number of conference rooms. Identify the principal subsystems.

Two discrete programs need to be written for this project: the client, which the users run; and the server, which would run on a separate machine. In addition, the client machine would have an administrative component to enable a system administrator to add new people and rooms.

If you decide to implement this as a client/server model, the client would accept input from users and generate a request to the server. The server would service the request and send back the results to the client. With this model, many people can schedule meetings at the same time.

On the client's side, there are two major subsystems in addition to the administrative module: the user interface and the communications subsystem. The server's side consists of three main subsystems: communications, scheduling, and a mail interface that would announce to the user when changes have occurred in the schedule.

4. Design and show the interfaces to the classes in the room-reservation portion of the program discussed in Exercise 3.

A meeting is defined as a group of people reserving a room for a certain amount of time. The person making the schedule might want a specific room, or a specified time; but the scheduler must always be told how long the meeting will last and who is required to attend.

The objects will probably include the users of the system as well as the conference rooms. Don't forget to include classes for the calendar, and perhaps a Meeting class that encapsulates all that is known about a particular event.

The prototypes for the classes might include:
class Calendar_Class;          // forward reference
class Meeting;               // forward reference
class Configuration
{
public:
     Configuration();
     ~Configuration();
     Meeting Schedule( ListOfPerson&, Delta Time
duration );
     Meeting Schedule( ListOfPerson&, Delta Time
duration, Time );
     Meeting Schedule( ListOfPerson&, Delta Time
duration, Room );
     ListOfPerson&     People();     // public
accessors
     ListOfRoom&     Rooms();     // public accessors
protected:
     ListOfRoom     rooms;
     ListOfPerson     people;
};
typedef long      Room_ID;
class Room
{
public:     
     Room( String name, Room_ID id, int capacity,
String directions = "", String description = "" );
     ~Room();
     Calendar_Class Calendar();
     
protected:
     Calendar_Class     calendar;
     int          capacity;
     Room_ID     id;
     String          name;
     String          directions;          // where is
this room?
     String          description;
};
typedef long Person_ID;
class Person
{
public:
     Person( String name, Person_ID id );
     ~Person();
     Calendar_Class Calendar();          // the access
point to add meetings
protected:
     Calendar_Class     calendar;
     Person_ID     id;
     String          name;
};
class Calendar_Class
{
public:
     Calendar_Class();
     ~Calendar_Class();
     
     void Add( const Meeting& );               // add a
meeting to the calendar
     void Delete( const Meeting& );                    
     Meeting* Lookup( Time );               // see if
there is a meeting at the 
                                   // given time
     
     Block( Time, Duration, String reason = "" );    
// allocate time to yourself...

protected:
     OrderedListOfMeeting meetings;
};
class Meeting
{
public:
     Meeting( ListOfPerson&, Room room, 
          Time when, Duration duration, String purpose
= "" );
     ~Meeting();
protected:
     ListOfPerson     people;
     Room          room;
     Time          when;
     Duration     duration;
     String          purpose;
};

Day 19

Quiz

1. What is the difference between a template and a macro?

Templates are built into the C++ language and are type-safe. Macros are implemented by the preprocessor and are not type-safe.

2. What is the difference between the parameter to a template and the parameter to a function?

The parameter to the template creates an instance of the template for each type. If you create six template instances, six different classes or functions are created. The parameters to the function change the behavior or data of the function, but only one function is created.

3. What is the difference between a type-specific template friend class and a general template friend class?

The general template friend function creates one function for every type of the parameterized class; the type-specific function creates a type-specific instance for each instance of the parameterized class.

4. Is it possible to provide special behavior for one instance of a template but not for other instances?

Yes, create a specialized function for the particular instance. In addition to creating Array<t>::SomeFunction(), also create Array<int>::SomeFunction() to change the behavior for integer arrays.

5. How many static variables are created if you put one static member into a template class definition?
One for each instance of the class.

Exercises

1. Create a template based on this List class:
class List
{
private:

public:
     List():head(0),tail(0),theCount(0) {}
     virtual ~List();

     void insert( int value );
     void append( int value );
     int is_present( int value ) const;
     int is_empty() const { return head == 0; }
     int count() const { return theCount; }
private:
     class ListCell
     {
     public:
          ListCell(int value, ListCell *cell = 0):val(value),next(cell){}
          int val;
          ListCell *next;
     };
     ListCell *head;
     ListCell *tail;
     int theCount;
};

Here is one way to implement this template:

template <class Type>
class List
{

public:
     List():head(0),tail(0),theCount(0) { }
     virtual ~List();

     void insert( Type value );
     void append( Type value );
     int is_present( Type value ) const;
     int is_empty() const { return head == 0; }
     int count() const { return theCount; }

private:
     class ListCell
     {
     public:
          ListCell(Type value, ListCell *cell = 0):val(value),next(cell){}
          Type val;
          ListCell *next;
     };

     ListCell *head;
     ListCell *tail;
     int theCount;
};
2. Write the implementation for the List class (non-template) version.
void List::insert(int value)
{
     ListCell *pt = new ListCell( value, head );
     assert (pt != 0);

     // this line added to handle tail
     if ( head == 0 ) tail = pt;

     head = pt;
     theCount++;
}

void List::append( int value )
{
     ListCell *pt = new ListCell( value );
     if ( head == 0 )
          head = pt;
     else
          tail->next = pt;
     
     tail = pt;
     theCount++;
}

int List::is_present( int value ) const
{
     if ( head == 0 ) return 0;
     if ( head->val == value || tail->val == value )
          return 1;
     
     ListCell *pt = head->next;
     for (; pt != tail; pt = pt->next)
          if ( pt->val == value )
               return 1;
          
     return 0;
}
3. Write the template version of the implementations.
template <class Type>
List<Type>::~List()
{
     ListCell *pt = head;
     
     while ( pt )
     {
          ListCell *tmp = pt;
          pt = pt->next;
          delete tmp;
     }
     head = tail = 0;
}

template <class Type>
void List<Type>::insert(Type value)
{
     ListCell *pt = new ListCell( value, head );
     assert (pt != 0);
     
     // this line added to handle tail
     if ( head == 0 ) tail = pt;
     
     head = pt;
     theCount++;
}

template <class Type>
void List<Type>::append( Type value )
{
     ListCell *pt = new ListCell( value );
     if ( head == 0 )
          head = pt;
     else
          tail->next = pt;
     
     tail = pt;
     theCount++;
}

template <class Type>
int List<Type>::is_present( Type value ) const
{
     if ( head == 0 ) return 0;
     if ( head->val == value || tail->val == value )
          return 1;
     
     ListCell *pt = head->next;
     for (; pt != tail; pt = pt->next)
          if ( pt->val == value )
               return 1;
          
     return 0;
}
4. Declare three List objects: a list of strings, a list of Cats and a list of ints.
List<String> string_list;
List<Cat> Cat_List;
List<int> int_List;
5. BUG BUSTERS: What is wrong with the following code? (Assume the List template is defined, and Cat is the class defined earlier in the book.)
List<Cat> Cat_List;
Cat Felix;
CatList.append( Felix );
cout << "Felix is " <<
     ( Cat_List.is_present( Felix ) ) ? "" : "not " << "present\n";
Hint: (this is tough) What makes Cat different from int?

Cat
doesn't have operator == defined; all operations that compare the values in the List cells, such as is_present, will result in compiler errors. To reduce the chance of this, put copious comments before the template definition stating what operations must be defined for the instantiation to compile.

6. Declare friend operator == for List.
friend int operator==( const Type& lhs, const Type& rhs );
7. Implement friend operator == for List.
template <class Type>
int List<Type>::operator==( const Type& lhs, const Type& rhs )
{
     // compare lengths first
     if ( lhs.theCount != rhs.theCount )
          return 0;     // lengths differ

     ListCell *lh = lhs.head;
     ListCell *rh = rhs.head;

     for(; lh != 0; lh = lh.next, rh = rh.next )
          if ( lh.value != rh.value )
               return 0;

     return 1;          // if they don't differ, they must match
}
8. Does operator== have the same problem as in Exercise 4?

Yes, because comparing the array involves comparing the elements, operator!= must be defined for the elements as well.

9. Implement a template function for swap, which exchanges two variables.
// template swap:
// must have assignment and the copy constructor defined for the Type.
template <class Type>
void swap( Type& lhs, Type& rhs)
{
     Type temp( lhs );
     lhs = rhs;
     rhs = temp;
}

Day 20

Quiz


1. What is an exception?

An exception is an object that is created as a result of invoking the keyword throw. It is used to signal an exceptional condition, and is passed up the call stack to the first catch statement that handles its type.

2. What is a try block?

A try block is a set of statements that might generate an exception.

3. What is a catch statement?

A catch statement has a signature of the type of exception it handles. It follows a try block and acts as the receiver of exceptions raised within the try block.

4. What information can an exception contain?

An exception is an object and can contain any information that can be defined within a user-created class.

5. When are exception objects created?

Exception objects are created when you invoke the keyword throw.

6. Should you pass exceptions by value or by reference?

In general, exceptions should be passed by reference. If you don't intend to modify the contents of the exception object, you should pass a const reference.

7. Will a catch statement catch a derived exception if it is looking for the base class?

Yes, if you pass the exception by reference.

8. If there are two catch statements, one for base and one for derived, which should come first?

catch
statements are examined in the order they appear in the source code. The first catch statement whose signature matches the exception is used.

9. What does catch(...) mean?

catch(...)
will catch any exception of any type.

10. What is a breakpoint?

A breakpoint is a place in the code where the debugger will stop execution.

Exercises

1. Create a try block, a catch statement, and a simple exception.
#include <iostream.h>
class OutOfMemory {};
int main()
{

     try
     {
          int *myInt = new int;
          if (myInt == 0)
               throw OutOfMemory();
     }
     catch (OutOfMemory)
     {
          cout << "Unable to allocate memory!\n";
     }
return 0;
 }
2. Modify the answer from Exercise 1, put data into the exception along with an accessor function, and use it in the catch block.
#include <iostream.h>
#include <stdio.h>
#include <string.h>
class OutOfMemory
{
public:
     OutOfMemory(char *);
     char* GetString() { return itsString; }
private:
     char* itsString;
};

OutOfMemory::OutOfMemory(char * theType)
{
     itsString = new char[80];
     char warning[] = "Out Of Memory! Can't allocate room for: ";
     strncpy(itsString,warning,60);
     strncat(itsString,theType,19);
}

int main()
{

     try
     {
          int *myInt = new int;
          if (myInt == 0)
               throw OutOfMemory("int");
     }
     catch (OutOfMemory& theException)
     {
          cout << theException.GetString();
     }
return 0;
 }
3. Modify the class from Exercise 2 to be a hierarchy of exceptions. Modify the catch block to use the derived objects and the base objects.
1:     #include <iostream.h>
2:
3:     // Abstract exception data type
4:     class Exception
5:     {
6:     public:
7:        Exception(){}
8:        virtual ~Exception(){}
9:        virtual void PrintError() = 0;
10:    };
11:
12:    // Derived class to handle memory problems.
13:    // Note no allocation of memory in this class!
14:    class OutOfMemory : public Exception
15:    {
16:    public:
17:       OutOfMemory(){}
18:       ~OutOfMemory(){}
19:       virtual void PrintError();
20:    private:
21:    };
22:
23:    void OutOfMemory::PrintError()
24:    {
25:       cout << "Out of Memory!!\n";
26:    }
27:
28:    // Derived class to handle bad numbers
29:    class RangeError : public Exception
30:    {
31:    public:
32:       RangeError(unsigned long number){badNumber = number;}
33:       ~RangeError(){}
34:       virtual void PrintError();
35:       virtual unsigned long GetNumber() { return badNumber; }
36:       virtual void SetNumber(unsigned long number) {badNumber =                        Ânumber;}
37:    private:
38:       unsigned long badNumber;
39:    };
40:
41:    void RangeError::PrintError()
42:    {
43:       cout << "Number out of range. You used " << GetNumber() <<                                Â"!!\n";
44:    }
45:
46:    void MyFunction();  // func. prototype
47:
48:    int main()
49:    {
50:       try
51:       {
52:          MyFunction();
53:       }
54:       // Only one catch required, use virtual functions to do the
55:       // right thing.
56:       catch (Exception& theException)
57:       {
58:          theException.PrintError();
59:       }
60:       return 0;
61:     }
62:
63:     void MyFunction()
64:     {
65:          unsigned int *myInt = new unsigned int;
66:          long testNumber;
67:          if (myInt == 0)
68:             throw OutOfMemory();
69:          cout << "Enter an int: ";
70:          cin >> testNumber;
71:          // this weird test should be replaced by a series
72:          // of tests to complain about bad user input
73:          if (testNumber > 3768 || testNumber < 0)
74:             throw RangeError(testNumber);
75:
76:          *myInt = testNumber;
77:          cout << "Ok. myInt: " << *myInt;
78:          delete myInt;
79:    }
4. Modify the program from Exercise 3 to have three levels of function calls.
1:     #include <iostream.h>
2:
3:     // Abstract exception data type
4:     class Exception
5:     {
6:     public:
7:        Exception(){}
8:        virtual ~Exception(){}
9:        virtual void PrintError() = 0;
10:    };
11:
12:    // Derived class to handle memory problems.
13:    // Note no allocation of memory in this class!
14:    class OutOfMemory : public Exception
15:    {
16:    public:
17:       OutOfMemory(){}
18:       ~OutOfMemory(){}
19:       virtual void PrintError();
20:    private:
21:    };
22:
23:    void OutOfMemory::PrintError()
24:    {
25:       cout << "Out of Memory!!\n";
26:    }
27:
28:    // Derived class to handle bad numbers
29:    class RangeError : public Exception
30:    {
31:    public:
32:       RangeError(unsigned long number){badNumber = number;}
33:       ~RangeError(){}
34:       virtual void PrintError();
35:       virtual unsigned long GetNumber() { return badNumber; }
36:       virtual void SetNumber(unsigned long number) {badNumber =                        Ânumber;}
37:    private:
38:       unsigned long badNumber;
39:    };
40:
41:    void RangeError::PrintError()
42:    {
43:       cout << "Number out of range. You used " << GetNumber() <<                        Â"!!\n";
44:    }
45:
46:    // func. prototypes
47:    void MyFunction();
48:    unsigned int * FunctionTwo();
49:    void FunctionThree(unsigned int *);
50:
51:    int main()
52:    {
53:       try
54:       {
55:          MyFunction();
56:       }
57:       // Only one catch required, use virtual functions to do the
58:       // right thing.
59:       catch (Exception& theException)
60:       {
61:          theException.PrintError();
62:       }
63:       return 0;
64:     }
65:
66:    unsigned int * FunctionTwo()
67:    {
68:       unsigned int *myInt = new unsigned int;
69:      if (myInt == 0)
70:        throw OutOfMemory();
71:      return myInt;
72:   }
73:
74:     void MyFunction()
75:     {
76:          unsigned int *myInt = FunctionTwo();
77:
78:          FunctionThree(myInt);
79:          cout << "Ok. myInt: " << *myInt;
80:          delete myInt;
81:    }
82:
83:    void FunctionThree(unsigned int *ptr)
84:    {
85:          long testNumber;
86:          cout << "Enter an int: ";
87:          cin >> testNumber;
88:          // this weird test should be replaced by a series
89:          // of tests to complain about bad user input
90:          if (testNumber > 3768 || testNumber < 0)
91:             throw RangeError(testNumber);
92:          *ptr = testNumber;
93:    }
5. BUG BUSTERS: What is wrong with the following code?
#include "stringc.h"          // our string class

class xOutOfMemory
{
public:
     xOutOfMemory( const String& where ) : location( where ){}
     ~xOutOfMemory(){}
     virtual String where(){ return location };
private:
     String location;
}

main()
{
     try {
          char *var = new char;
          if ( var == 0 )
               throw xOutOfMemory();
     }
     catch( xOutOfMemory& theException )
     {
          cout << "Out of memory at " << theException.location() << "\n";
     }
}
In the process of handling an "out of memory" condition, a string object is created by the constructor of xOutOfMemory. This exception can only be raised when the program is out of memory, so this allocation must fail.

It is possible that trying to create this string will raise the same exception, creating an infinite loop until the program crashes. If this string is really required, you can allocate the space in a static buffer before beginning the program, and then use it as needed when the exception is thrown.

Day 21

Quiz

1. What is the difference between strcpy() and strncpy()?

strcpy(char* destination, char* source)
copies source to destination, and puts a null at the end of destination. destination must be large enough to accommodate source, or strcpy() will simply write past the end of the array. strncpy(char* destination char* source, int howmany) will write howmany bytes of source to destination, but will not put a terminating null.

2. What does ctime() do?

ctime()
takes a time_t variable and returns an ASCII string with the current time. The time_t variable is typically filled by passing its address to time().

3. What is the function to call to turn an ASCII string into a long?
atol()
4. What does the complement operator do?

It flips every bit in a number.

5. What is the difference between OR and exclusive OR?

OR
returns TRUE if either or both bits are set; exclusive OR returns TRUE only if one, but not both, is set.

6. What is the difference between & and &&?

&
is the bitwise AND operator, and && is the logical AND operator.

7. What is the difference between | and ||?

|
is the bitwise OR operator, and || is the logical OR operator.


Exercises

1. Write a program to safely copy the contents of a 20-byte string into a 10-byte string, truncating whatever won't fit.
1:     #include <iostream.h>
2:     #include <string.h>
3:
4:     int main()
5:     {
6:        char bigString[21] = "12345678901234567890";
7:        char smallString[10];
8:        strncpy(smallString,bigString,9);
9:        smallString[9]='\0';
10:       cout << "BigString: " << bigString << endl;
11:       cout << "smallString: " << smallString << endl;
12:       return 0;
13:    }
2. Write a program that tells the current date in the form 7/28/94.
1:     #include <iostream.h>
2:     #include <time.h>
3:
4:     int main()
5:     {
6:        time_t currentTime;
7:        struct tm *timeStruct;
8:        time (&currentTime);
9:        timeStruct = localtime(&currentTime);
10:
11:       cout << timeStruct->tm_mon+1 << "/";
12:       cout << timeStruct->tm_mday << "/";
13:       cout << timeStruct->tm_year << " ";
14:       return 0;
15:    }
3. Write the definition of a class that uses bit fields to store whether the computer is monochrome or color, a PC or Macintosh, a laptop or a desktop, and whether it has a CD-ROM.
#include <iostream.h>
enum Boolean { FALSE = 0, TRUE = 1 };

class Computer
{
public:  // types
     enum Machine { Mac = 0, PC };

public:  // methods
     Computer( Boolean color, Boolean laptop, Machine kind, Boolean cdrom )
          : Color( color ), Laptop( laptop ), Kind( kind ), CDRom( cdrom ){}
     ~Computer(){}

     friend ostream& operator<<( ostream& os, const Computer& computer );

private:
     Boolean Color : 1;
     Boolean Laptop : 1;
     Machine Kind : 1;
     Boolean CDRom : 1;
};

     ostream&
operator<<( ostream& os, const Computer& computer )
{
     os << "[";
     ( computer.Color ) ? os << "color" : os << "monochrome";
     os << ", ";
     ( computer.Laptop ) ? os << "laptop" : os << "desktop";
     os << ", ";
     ( computer.Kind ) ? os << "PC" : os << "Mac";
     os << ", ";
     ( computer.CDRom ) ? os << "" : os << "no ";
     os << "CD-Rom";
     os << "]";
     return os;
}
 int main()
{
     Computer pc( TRUE, TRUE, Computer :: PC, TRUE );

     cout << pc << `\n';
     return 0;
}
4. Write a program that creates a 26-bit mask. Prompt the user to enter a word, and then quickly report on which letters were used in setting and reading the bits (one bit per character). The program should treat upper- and lowercase letters as the same.
#include <ctype.h>
#include <iostream.h>
#include <string.h>

class Bits
{
public:
     enum { BITS_PER_INT = 16 };
     Bits( int cnt );
     virtual ~Bits();

     void clear();
     void set( int position );
     void reset( int position );
     int is_set( int position );
private:
     unsigned int * bits;
     int count;
     int Ints_Needed;
};

class AlphaBits : private Bits
{
public:
     AlphaBits() : Bits( 26 ){}
     ~AlphaBits(){}

     void clear() { Bits::clear(); }
     void set( char );
     void reset( char );
     int is_set( char );
};

Bits :: Bits( int cnt ) : count( cnt )
{
     Ints_Needed = count / BITS_PER_INT;

     // if there is a remainder, you need one more member in array
     if ( 0 != count % BITS_PER_INT )
          Ints_Needed++;

     // create an array of ints to hold all the bits
     bits = new unsigned int[ Ints_Needed ];

     clear();
}

Bits :: ~Bits()
{
     delete [] bits;
}

void Bits :: clear()
{
     // clear the bits
     for ( int i = 0; i < Ints_Needed; i++ )
          bits[ i ] = 0;
}

void Bits :: set( int position )
{
     // find the bit to set
     int Int_Number = position / BITS_PER_INT;
     int Bit_Number = position % BITS_PER_INT;

     // create mask with that one bit set
     unsigned int mask = 1 << Bit_Number;

     // set the bit
     bits[ Int_Number ] |= mask;
}

// clear the bit
void Bits :: reset( int position )
{
     int Int_Number = position / BITS_PER_INT;
     int Bit_Number = position % BITS_PER_INT;

     unsigned int mask = ~( 1 << Bit_Number );

     bits[ Int_Number ] &= mask;
}

int Bits :: is_set( int position )
{
     int Int_Number = position / BITS_PER_INT;
     int Bit_Number = position % BITS_PER_INT;

     unsigned int mask = 1 << Bit_Number;

     return ( 0 != ( bits[ Int_Number ] & mask ) );
}

void AlphaBits :: set( char s )
{

     // make sure the requested character is an alphabetic character
     // if so, force it to lower case, then subtract the ascii value
     // of `a' to get its ordinal (where a = 0, b =1) and set that bit
     if ( isalpha( s ) )
          Bits :: set( tolower( s ) - `a' );
}

void AlphaBits :: reset( char s )
{
     if ( isalpha( s ) )
          Bits :: reset( tolower( s ) - `a' );
}

int AlphaBits :: is_set( char s )
{
     if ( isalpha( s ) )
          return Bits :: is_set( tolower( s ) - `a' );
     else
          return 0;
}

int main()
{
     AlphaBits letters;

     char buffer[512];

     for (;;)
     {
          cout << "\nPlease type a word (0 to quit): ";
          cin >> buffer;

          if (strcmp(buffer,"0") == 0)
             break;

          // set the bits
          for ( char *s = buffer; *s; s++ )
               letters.set( *s );

          // print the results
          cout << "The letters used were: ";
          for ( char c = `a'; c <= `z'; c++ )
               if ( letters.is_set( c ) )
                    cout << c << ` `;
          cout << `\n';

          // clear the bits
          letters.clear();
     }
    return 0;

5. Write a program that sorts the command-line parameters. If the user enters SortFunc cat bird fish dog, the program prints bird cat dog fish.
#include <string.h>
#include <iostream.h>

void swap ( char* &s, char* &t )
{
     char* temp = s;
     s = t;
     t = temp;
}

int main( int argc, char* argv[] )
{
     // Since argv[0] is the program name, 
     //we don't want to sort or print it;
// we start sorting at element 1 (not 0).

     // a "Bubble Sort" is used because of the small number of items.
     int i,j;
     for ( i = 1; i < argc; i++ )
          for ( j = i + 1; j < argc; j++ )
               if ( 0 < strcmp( argv[i], argv[j] ) )
                    swap( argv[i], argv[j] );


     for ( i = 1; i < argc; i++ )
          cout << argv[i] << ` `;

     cout << `\n';
    return 0;
}
6. Write a program that adds two numbers without using the addition operator (+), subtraction
operator (-), increment (++), or decrement (--). Hint: Use the bit operators!

If you take a look at the addition of two bits, you'll notice the answer will contain two bits: the result bit and the carry bit. Thus, adding 1 and 1 in binary results in 1 with a carry of 1. If we add 101 to 001, here are the results:
101  // 5
001  //1
110  //6
If you add two "set" bits (each is valued as one), the result is that the result bit is 0 but the carry bit is 1. If you add two clear bits, both the result and the carry are 0. If you add two bits with one set and the other clear, the result bit is 1, but the carry bit is 0. Here is a table that summarizes these rules:
lhs   rhs   |   carry   result
------------+------------------
0     0     |   0       0
0     1     |   0       1
1     0     |   0       1
1     1     |   1       0
Examine the logic of the carry bit. If both bits to be added (lhs and rhs) are 0 or either side is 0, the answer is 0. Only if both bits are 1 is the answer 1. This is exactly the same as the AND operator (&).

In the same way, the result is an XOR (^) operation: if either bit is 1 (but not both), the answer is 1; otherwise, the answer is 0.

When you get a carry, it is added to the next most significant (leftmost) bit. This implies either iterating through each bit or recursion.

#include <iostream.h>

unsigned int add( unsigned int lhs, unsigned int rhs )
{
     unsigned int result, carry;

     while ( 1 )
     {
          result = lhs ^ rhs;
          carry = lhs & rhs;

          if ( carry == 0 )
               break;

          lhs = carry << 1;
          rhs = result;
     };

     return result;
}

int main()
{
     unsigned long a, b;
     for (;;)
     {
          cout << "Enter two numbers. (0 0 to stop): ";
          cin >> a >> b;
          if (!a && !b)
               break;
          cout <<a << " + " << b << " =  " << add(a,b) << endl;
     }
    return 0;
}
Alternatively, you can solve this problem with recursion:
#include <iostream.h>

unsigned int add( unsigned int lhs, unsigned int rhs )
{
     unsigned int carry = lhs & rhs;
     unsigned int result = lhs ^ rhs;

     if ( carry )
          return add( result, carry << 1 );
     else
          return result;
}

int main()
{
     unsigned long a, b;
     for (;;)
     {
          cout << "Enter two numbers. (0 0 to stop): ";
          cin >> a >> b;
          if (!a && !b)
               break;
          cout <<a << " + " << b << " =  " << add(a,b) << endl;
     }
    return 0;
}