Name (2 pts):

Section (2 pts):

Question 1 (10 pts):

int doSomething(int &x, int y) {
  int temp = y;
  y = x/2;
  x = temp/2;
  cout << x << " " << y << endl;
  return y;
}

1. cout << doSomething(20, 30) << endl;
   cout << 20 << " " << 30 << endl;
   
   Does not compile. You can't pass an integer literal by
   reference. 
   
   
   

2. int a = 10;
   const int b = 20;  
   
   cout << doSomething(a, b) << endl;
   cout << a << " " << b << endl;
   
   10 5
   5
   10 20
   

3. int a = 20;
   
   cout << doSomething(a, a) << endl;
   cout << a << " " << a << endl;
   
   10 10
   10
   10 10
   

Functions are an abstraction; abstraction within the implementation of a class, but not available to clients of that class, is just as important in managing the complexity of the program as is the abstraction modeled by the class itself. Helper functions used by public methods to simplify the code, or allow code reuse, should be private methods, especially if they must manipulate private data members.

Question 3 (12 pts):

switch(color) {
case red:
  cout << "Your lips are like sweet roses" << endl;
  break;
case blue:
  cout << "Your eyes are limpid pools of loveliness" << endl;
case green:
  cout << "Your hair is like a waterfall,"
       << " only with Mountain Dew(tm)," 
       << " except on the sides, where it is more like the green on"
       << " hole 5 at Pebble Beach." << endl;
case black:
  cout << "That's the coolest shirt I've ever seen."
       << "  Einstuerzende Neubauten rule!" << endl;
default:
  cout << "How can I describe your beauty?" << endl;
}

enum COLOR { red, blue, green, black };
COLOR color;

Question 4 (10 pts):
Consider the following definition of class Fraction:

class Fraction {
public:
  ... // all the member functions go here
private:
  char *value; // a dynamically allocated string containing the value of the 
	       // Fraction, such as "22/7"
}

There is (practically) no possibility of overflow in terms of storage and operations performed on fractions. Implementation of arithmetic operators and the expand function will be more difficult (and slower). The client should not care, since the differences are hidden behind the abstraction barrier, although it is acceptable to say that the client might care because this implementation might be slower etc.

Question 5 (12 pts):

void Dog::eat(Food f) {
  if(like(f)) {
    tail.wag();
  } else {
    bite(owner);
  }
}

XX a public data member of Dog
XX a private data member of Dog
__ a public member function of Dog
__ a private member function of Dog
XX a global variable
__ a local variable
__ an enumerated type

Circle the answer that is most appropriate, and give a brief justification.

If tail were a global variable, all dogs would have to share the same tail. If tail were a public data member, clients of the dog class would be able to access a dog's tail directly, which is probably not the intent of the dog class.

void swap(int* x, int* y) {
  int temp = *x;
  *x = *y;
  *y = temp;
}

void sneakySwap(int x, int y) {
  swap(&x, &y);
  cout << x << " " << y << endl;
}

int a = 10;
int b = 20;

sneakySwap(a, b);
cout << a << " " << b << endl;

20 10
10 20

class IntList2 {
public:
  IntList2();

  isEmpty();
  getSize();

  void start();
  void advance();
  bool atEnd();
  int getData();

  void insertBefore(int item);
  void insertAfter(int item);
  void deleteItem();

private:
  IntStack front;
  IntStack rear;

  int size;
};

bool IntList2::isEmpty() {


  return front.isEmpty() && rear.isEmpty();
}

void IntList2::advance() {
  assert(!atEnd());
  front.push(rear.pop());


}

bool IntList2::atEnd() {


  return rear.isEmpty();
}

int IntList2::getData() {
  assert(!rear.isEmpty());


  return rear.top();
}

void IntList2::insertAfter(int item) {
  assert(!atEnd());
  front.push(rear.pop());
  rear.push(item);

  size++;
}

void IntList2::deleteItem() {
  assert(!atEnd());
  rear.pop();

  size--;
}

void IntList2::insertBefore(int item) {

  rear.push(item);
  size++;







}

void IntList2::start() {

  while(!front.isEmpty()) {
    rear.push(front.pop());
  }






}

int IntList2::getSize() { // this may involve adding to the private
                          // part of the class and/or the implementations of
                          // the above functions

  return size;











}

int factorial(int x) {

  assert(x >= 0);

  if(x == 0) {

    return 1;

  }


  int total = x--;


  while(x > 0) {


    total *= x--;


  }


  return total;


}

int factorial(int x) {
  if(x < 0) {
    return x;
  }
  if(x == 0) {


    return 1;


  }


  int total = x--;


  while(x > 0) {


    total *= x--;


  }


  return total;


}