CMSC 202
Final Exam Study Guide

Use the list of questions below as a guide when studying for the final exam. It is by no means a comprehensive list of all material that you are responsible for. In general, you are responsible for the material presented in lecture and in the labs since the midterm exam. However, by its very nature, this programming course is cumulative and so to some degree the final will also be cumulative but will emphasize the material presented after the midterm. You are also responsible for all associated reading assignments. Be sure to check out any student exercises found in the lecture notes. Answering the "self-test" questions in each chapter of the text is also a good way to review.

For all TRUE/FALSE questions below which are FALSE, explain why.

I.Pointers and Dynamic Memory

1. Define "memory leak".
2. Given the following statements that allocate dynamic memory, write the corresponding statements to free the memory.
   1. string *p = new string;
   2. string *p = new string[3];
   3. Time *p = new Time(12, 0, 0);
   4. int *p = new int(33);
   5. int *p = new int[33];
3. Identify and explain how to fix any errors in the following code. Assume the proper #includes and namespace std. int main ( ) { int *p1 = new int (5); int *p2 = p1; cout << "p1 is pointing to the value " << *p2 << endl; delete [] p1; delete p2; return 0;
4. Explain what happens in the following new and delete expressions Car *parkingLot = new Car[50]; delete [] parkingLot;

   II.Copy Constructor and Assignment Operator

5. Why must the parameter to the copy constructor be passed by (const) reference?
6. Write the prototype for the copy constructor of a class named AB123YZ.
7. Given the declaration string bob = "bobby"; which of the following invoke the copy constructor?
   1. string mary = bob;
   2. string mary( bob );
   3. string mary = "bob";
8. Under what condition(s) will the default copy constructor supplied by the compiler lead to memory leaks or runtime errors?
9. What is the purpose of the test if (this != &rhs) in the code for operator= (where rhs is the parameter)?
10. Why does the assignment operator always return *this?
11. Define deep copy, shallow copy
12. Given the following class definitions class Point class Circle { { public: public: Point( int x = 0, int y = 0); Circle (const Point& p, int radius); int GetX ( void ) const; const Point& GetCenter( void ) const; int GetY ( void ) const; int GetRadius( void ) const; void Move (int deltaX, int deltaY); void Move (int deltaX, int deltaY); private: private: int m_xcoordinate; Point m_center; int m_ycoordinate; int m_radius; }; }; and the declarations Point point(3, 6); Circle circle1 (point, 5); Circle circle2 (Point (1, 2), 3);
    1. Write the copy constructor for Point
    2. Write the assignment operator Point
    3. Write the copy constructor for Circle
    4. Write the assignment operator Circle

    III. Inheritance and Polymorphism

13. Explain the differences among public, private, and protected member access specifiers. Be sure to mention their role in inheritance.
14. Explain how inheritance promotes code reuse.
15. Explain the difference between the "is a" and "uses a" relationships. Give an example of each from the course projects.
16. Explain how C++ implements the "is a" relationship between objects.
17. Explain how C++ implements the "has a" relationship between objects.
18. Describe the order in which constructors and destructors are called when using inheritance.
19. Explain the use of the member initialization list for constructors.
20. Explain the difference between function overriding and function overloading.
21. In terms of interface and implementation, what is the purpose of a pure virtual method in a base class?
22. In terms of interface and implementation, what is the purpose of a virtual method in a base class?
23. In terms of interface and implementation, what is the purpose of a non-virtual method in a base class?
24. Explain the difference between static (early) and dynamic(late) binding.
25. Define abstract base class. Give an example from one of the course projects.
26. Why should destructors be virtual in a base class?
27. Does polymorphism work through several layers of inheritance?
28. Although overriding a non-virtual function is permitted, it's not a good idea. Explain why this is true.

    True/False

29. A base class contains all data and methods which are common to all objects in its inheritance hierarchy.
30. In C++, public inheritance is used to support the "uses-a" relationship between objects.
31. Aggregation (composition) is used to support the "has-a" relationship between objects.
32. Like friends, a derived class has direct access to the base class' private data and methods.
33. Dynamic binding is performed at run-time when the programmer uses pointers to functions.
34. Because only virtual and pure virtual methods should be overridden, all public methods in a base class should be declared as either virtual or pure virtual.
35. The base class destructor is automatically called when a derived class object is destroyed.
36. Polymorphism can only occur when using indirect access (pointers or references ) to derived objects.
37. Polymorphism can only occur when using virtual or pure virtual methods.
38. To invoke a virtual function for an object, your code must use a pointer of the same type as the type of the object when it was originally declared.
39. If a member function was declared as " virtual void foo() = 0;" then it is not necessary to provide any definition of "foo" in the class.
40. Polymorphism refers to how identical code can produce different effects depending on the actual type of the object being processed.
41. Class member functions may not be declared "protected".
42. The base class assignment operator is automatically called when a derived class assignment operator is used.
43. The base class default constructor is automatically called when a derived class constructor is used unless a different base class constructor is specified in the member initialization list.

    int main ( ) { Lot ParkingLot; Car chevy; Car camry; MotorCycle harley(3); MotorCycle honda; ParkingLot.Park (chevy); ParkingLot.Park (honda); ParkingLot.Park (harley); ParkingLot.Park (camry); ParkingLot.Print( ); cout << endl; cout << "The lot has: " << ParkingLot.TotalWheels( ) << " wheels" << endl; return 0; }

    // Vehicle class class Vehicle { public: Vehicle ( int nrWheels = 0 ); virtual ~Vehicle ( ); virtual void Print ( ) const; int GetWheels ( ) const; void SetWheels (int wheels ); private: int m_nrWheels; }; //------------------------------------ Vehicle::Vehicle (int wheels) { m_nrWheels = wheels; } //------------------------------------- int Vehicle::GetWheels ( ) const { return m_nrWheels; } void Vehicle::SetWheels (int wheels) { m_nrWheels = wheels; } void Vehicle::Print ( ) const { cout << "Vehicle"; } Vehicle::~Vehicle ( ) { // no code }

    // Parking Lot class const int maxVehicles = 20; class Lot { public: Lot ( ); int NrParked ( ) const; void Park ( Vehicle& v ); int TotalWheels ( ) const; void Print( ) const; private: int m_nrVehicles; Vehicle *m_vehicles[maxVehicles]; }; //-------------------------------- Lot::Lot ( ) { m_nrVehicles = 0; } //---------------------------------- int Lot::NrParked ( ) const { return m_nrVehicles; } //---------------------------------- void Lot::Park (const Vehicle& vehicle) { m_vehicles[nrVehicles++] = &vehicle; } //---------------------------------- void Lot::Print ( ) const { for (int v = 0; v < nrParked(); v++) { (m_vehicles[v])->Print( ); cout << ":"; cout << (m_vehicles[v])->GetWheels(); cout << endl; } } //--------------------------------- int Lot::TotalWheels ( ) const { int w = 0; for (int v = 0; v < NrParked(); v++) w += (m_vehicles[v])->GetWheels(); return w; }

    // MotorCycle class class MotorCycle : public Vehicle { public: MotorCycle (int wheels = 2); ~MotorCycle ( ); }; //--------------------------------- MotorCycle::MotorCycle (int wheels) : Vehicle (wheels) { // no code } //=================== // Car class class Car : public Vehicle { public: Car (int wheels = 4); void Print ( ) const; }; //------------------------------ Car::Car (int wheels) : Vehicle (wheels) { // no code } void Car::Print ( ) const { cout << "Car"; }

    The following questions refer to the code above

44. What two features of this code tell you that dynamic binding is taking place? Be specific.
45. What is the output from main() ?
46. Write the copy constructor for the Motorcycle class.
47. Write the assignment operator for the Motorcycle class.
48. Write the destructor for the Motorcycle class.
49. True/False -- The Vehicle class is an abstract class.
50. True/False -- Motorcycle is derived from Vehicle.
51. True/False -- Car is derived from Vehicle.
52. True/False -- The Lot class is not intended to be a base class.
53. True/False -- The compiler will prevent the Car class from overriding Vehicle's GetWheels() method.
54. True/False -- The compiler will not prevent the Car class from overriding Vehicle's GetWheels() method, but it shouldn't do so.
55. True/False -- SetWheels() cannot be used polymorphically because it's not a virtual or pure virtual function.
56. True/False -- TotalWheels() is a polymorphic function.

    IV. Templates

57. Consider this prototype for a template function: template <class Item> void foo(Item x); Which is the right way to call the foo function with an integer argument i?
    1. foo( i );
    2. foo<int>( i );
    3. foo<Item>( i );
    4. foo(<int> i );
    5. foo(<Item> i );
58. Consider the following definition: template <class Item> Item max (Item a, Item b) { if (a > b) return a; else return b; } What restrictions are placed on the Item data type for a program that uses the max function?
    1. The Item data type must be either int, double, or float.
    2. The Item data type must be one of the built-in C++ data types.
    3. The Item data type must have a copy constructor and operator > defined.
    4. None of the above restrictions apply.
59. When should a function be implemented as a template function?
    1. When the data types of the parameters all have copy constructors.
    2. When the function's algorithm is independent of the underlying data type.
    3. When the function is relatively short (usually just one line).
    4. When the function only takes one argument.
60. Write a template function named Largest( ) that returns the largest object in a vector of homogeneous objects passed to it. The return value is the index into the vector at which the largest object was found. If more than one object is "largest", return the index of the first one found.
61. Write a small code fragment (variable declarations and function call) that shows how Largest( ) would be called from main( ) for a vector of objects of type BOB.
62. What attribute(s) of a function makes it appropriate to be a function template?
63. Write a template class definition for a class named Box that contains homogeneous data and supports the following operations. The capacity of the Box cannot change. What design decisions must be considered for these Box operations?
    1. Create a new Box. The capacity of the box is 25 items by default unless another capacity is specified by the user when the box is created.
    2. Puts an item into the Box
    3. Removes an item from the Box
    4. Tells how many items are in the Box
    5. Empties the box

       Given the class template for Box above

    6. Write a declaration for a Box that holds 10 integers
    7. Write a declaration for Box that holds 25 XYZ objects
    8. Write the code for operator<< for the Box class
    9. What syntax error, if any, is present in this implementation for the Box destructor? template <class T> Box::~Box( ) { // code here }
64. Given the following class: class MyArray { public: MyArray(); ~MyArray(); int &operator[](int k); private: int m_theData[66]; }; Rewrite the definition (do not define the member function and constructors, just declare them) as a template class which takes the type being stored as a template argument.
65. Implement the member function operator[] for the MyArray class above. Throw an exception of your choosing if you detect a bad index.

    V. Exceptions

66. Name one important advantage of using the C++ exception methodology.
67. Briefly explain when exception handling should be used.
68. Briefly explain how exceptions are implemented in C++.
69. Describe the process of "stack unwinding" which occurs if an exception is not caught.
70. Describe the basic functionality of an auto_ptr.
71. Explain why you should use auto_ptrs in code that might throw an exception.
72. What is meant by the term "exception safe code"?
73. What are the generally accepted classifications of exception safety that a function can make?
74. Rewrite the following function so that any exceptions which are thrown by the functions set(), game(), and match() are caught within the function play(). Your code should print a message indicating the type of exception caught and then call exit() if any exception is thrown. Assume that match() throws objects of type MatchEx and game() throw objects of type GameEx, both of which are defined elsewhere. Assume that set() throws an integer. Score play( void ) { Score s; while (!match( )) { while (!game( )) { s = set( ); } } return s; }

    True/False

75. Exception classes are different from other classes because they can only contain error messages.
76. Only one try block is allowed in a program.
77. A try block can have multiple catch blocks.
78. Exceptions that are not caught by your program result in a run-time error and core dump.
79. Exceptions should be caught by reference to avoid unnecessary copying.

    VI. Containers and Iterators

80. Define "container class" and give two examples from the STL.
81. What C++ mechanism is used to define containers?
82. Define iterator. What is the purpose of an iterator?
83. Explain the advantages of using iterators for containers.
84. Why are iterators required for some containers?
85. Given the code fragment below, write a for-loop using iterators that prints the contents of the vector vector< int > iVector; iVector.push_back( 42 ); iVector.push_back( 22 ); iVector.push_back( 32 ); iVector.push_back( 82 ); iVector.push_back( 62 ); iVector.push_back( 12 ); iVector.push_back( 72 ); // write your for-loop here
86. How would the for-loop you wrote in the question above be different if the container were a set instead of a vector?
87. Explain the difference between "constant", and "mutable" iterators.
88. Explain the difference between "forward" and "reverse" iterators.

    True/False

89. Some containers handle duplicate elements.
90. You may instantiate multiple iterators for the same container in the same program/function.
91. Iterators are created by the container.