Midterm 2 Solution

CS18

1. Short Answer Problems.
   1. (35 pts.) For a class declaration define public, private, protected, constructor, and destructor.
      • Public --- Member functions or variables which any function may access.
      • Protected --- Member functions or variables which only member functions of member function of derived classes may access.
      • Private --- Member functions or variables which only member functions may access.
      • Constructor --- A function called when a class variable comes into scope, usually to initialize the variable.
      • Destructor --- A function called when a class variable goes out of scope, usually to ``tear-down'' the variable.

   2. (20 pts.) Use the typedef statement to define the following two new types and show how to declare a variable of each of the new types.
      1. An int array with 20 elements.

         typedef int array[20];
         
         array d;
         

      2. A complex number (use a structure implementation).

         typedef struct Complex
         {
            double re, im;
         } complex;
         
         complex x;
         

   3. (20 pts.) Consider the following declaration:

      double data[] = { 1.0, 2.0, 3.0, 4.0 };
      

      Assume that a double occupies four bytes and that data is allocated starting at address 1000 in memory.
      1. How many elements are contained in data?
         4
      2. What is printed by

         cout << data;
         

         1000
      3. What is printed by

         double* p = data + 1;
         p += 2;
         cout << *p;
         

         4.0
      4. What is printed by

         double* p = data;
         p += 2;
         cout << p;
         

         1008

2. Programming Problems. Each of the following problems is worth 50 points. You are more likely to receive partial credit if you write your code so that I can understand what you've done.
   1. Consider the following implementation of a list:

      const int LIST_MAX = 100;
      
      class List
      {
       private:
         int l[LIST_MAX];   // Holds the items of the list.
         int size;          // Number of items in the list.
      
       public:
         List(void) : size(0) {}
         void ListRetrieve(int index, int& value, int* success);
         int ListLength(void);
         int ListIsEmpty(void);
         // ...
      };
      

      Implement ListRetrieve() (read the prototype carefully), ListLength(), and
      ListIsEmpty().

      void List::ListRetrieve(int index, int& value, int *success)
      {
         if (0 <= index && index < size)
         {
            value = l[index];
            *success = 1
         }
         else
            *success = 0;
      }
      
      int List::ListLength(void)
      {
         return size;
      }
      
      int List::ListIsEmpty(void)
      {
         return size == 0;
      }
      

   2. Design a single class which holds geometric objects, in this case either rectangles or circles. Several data members will be required:
      • A flag indicating if the object is a rectangle or circle.
      • If the object is a rectangle, two points. One point is the lower left corner, the other is the upper right corner.
      • If the object is a circle, a point and a radius.
      Use the following structure to represent points:

      struct point
      {
         double x;
         double y;
      };
      

      Show the class declaration and the definition of the class' constructors (one for creating a rectangle and one for creating a circle) and a public method which computes and returns the area of an object.

      enum ObjectType { CIRCLE, RECTANGLE };
      class Object
      {
       private:
         ObjectType type;
         point ll;
         point ur;
         point c;   // Center or circle.  I could have used one of the other
                    // two to save some space.
         double radius;
      
       public:
         // Circle constructor.
         Object(double x, double y, double rad);
         // Rectangle constructor.
         Object(double llx, double lly, double urx, double ury);
         double Area(void);
      };
      
      Object::Object(double x, double y, double rad)
      {
         type = CIRCLE;
         c.x = x;
         c.y = y;
         radius = rad;
      }
      
      Object::Object(double llx, double lly, double urx, double ury)
      {
         type = RECTANGLE;
         ll.x = llx;
         ll.y = lly;
         ur.x = urx;
         ur.y = ury;
      }
      
      double Object::Area(void)
      {
         switch (type)
         {
          case RECTANGLE:
            return (ur.x - ll.x) * (ur.y - ll.y);
            break;
          case CIRCLE:
            return PI * radius * radius;
            break;
          default:   // This is a major fault.  Terminate.
            exit(1);
            break;
         }
      }