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;
         }
      }
      



Thomas P. Kelliher
Tue Apr 23 00:25:44 EDT 1996
Tom Kelliher