Midterm Answers

Advantages: Parts of the program can be written in different languages. If changes are made to the program, we only need to recompile the source files which contain the changes, not the whole program. Different programmers can be working on different parts of the program at the same time. It is easier to write commonly used modules and use them in different programs. Disadvantages: Difficulty in deciding how to split up the program into modules. If a subroutine X in one source file calls a subroutine Y contained in another source file, how do we ensure that Y exists, X is calling Y with the correct number of parameters, X is calling Y with the correct parameter types, X is expecting the correct type of value returned by Y. If a subroutine X in one source file uses a variable Y contained in another source file, how do we ensure that Y exists, X knows the correct type of Y. How do we prevent the same subroutine or variable from being defined in different source files? Or should we prevent this? How can a subroutine in one source file call a subroutine in another source file if they are written in different programming languages?

When a parameter is passed by value, the function gets its own copy of the parameter value. If the function makes changes to its copy of the parameter, the original parameter is unchanged. When a parameter is passed by reference, the function has access to the actual parameter that was passed. If the function makes changes to the parameter, the original parameter is changed, since the function is accessing the original parameter.

We want the function to be able to change the value of a parameter. It the parameter is a large item (such as a struct), passing by reference is much faster.

    class Person {
      public:
         Person();
         ~Person();
         friend ostream & operator<<(ostream &, Person &);
      private:
         char name[20];
         int  age;
         int  weight;
   };
          

   Name: Henry Ford
   Age: 32
   Weight: 185
   

ostream & operator<<(ostream & os, Person & p) { os << "Name: " << p.name << endl << "Age: " << p.age << endl << "Weight: " << p.weight << endl; return os; }

To allow the compiler to check, in one pass, that each function is being called with the correct number of parameters, with the correct parameter types, and with the correct return value type being expected.

     #include <iostream.h>
     
     class elephant {
        public:
           elephant();
           elephant(const int i);
           elephant(const elephant & c);
           ~elephant();
           elephant & operator=(const elephant & c);
        private:
           int size;
        };
     
     elephant::elephant() {
        size = 3;
        cout << "default constructor: size = " << size << endl;
     }
     
     elephant::elephant(const int i) {
        size = i;
        cout << "int constructor: size = " << size << endl;
     }
     
     elephant::elephant(const elephant & c) {
        size = c.size;
        cout << "elephant constructor: size = " << size << endl;
     }
     
     elephant::~elephant() {
        cout << "destructor: size = " << size << endl;
     }
     
     elephant & elephant::operator=(const elephant & c) {
        size = c.size;
        cout << "assignment operator: size = " << size << endl;
        return *this;
     }
     
     int main() {
       elephant a;
       elephant b(7);
       elephant c = b;
       elephant * d = new elephant(4);
     
       delete d;
       c = a;
     
       return 0;
     }
         

default constructor: size = 3 int constructor: size = 7 elephant constructor: size = 7 int constructor: size = 4 destructor: size = 4 assignment operator: size = 3 destructor: size = 3 destructor: size = 7 destructor: size = 3

   #include <iostream.h>
     
   class myObject {
      public:
         myObject(int i, int j) { x = i; y = j; }
         void SetX(int i) { x = i; }
         void SetY(int i) { y = i; }
         static void ShowX() { cout << "x = " << x << endl; }
         void ShowY() { cout << "y = " << y << endl; }
         static void increment() { x++; }
      private:
         static int x;
         int y;
      };

   int myObject::x = 5;

   int main() {
      static myObject a(3, 4);
      myObject b(7, 8);

      a.ShowX();
      a.ShowY();
      b.ShowX();
      b.ShowY();

      a.SetX(1);
      b.increment();
      myObject::increment();

      a.ShowX();
      a.ShowY();
      b.ShowX();
      b.ShowY();

      return 0;
   }        
   

x = 7 y = 4 x = 7 y = 8 x = 3 y = 4 x = 3 y = 8

the first one

     #include <stdlib.h>
     #include <iostream.h>
     
     int a = 4;
     static float b = 2.73;
     
     int evaluate(char c = 'X') {
        static bool d = true;
        int e = 0;
     
        if (c != 'X') {
           e++;
           d = (e < 5);
           }
     
        return e;
     }
     
     int main() {
        char * f = NULL;
     
        f = new char('H');
        a = evaluate(*f);
        delete f;
     
        return 0;
     }
   

	Scope	Lifetime
a	global	static
b	module	static
c	local	automatic
d	local	static
e	local	automatic
f	local	dynamic

   #include <iostream.h>
     
   int main() {
      int   a = 3;
      int & b = a;
      int * c = &a;
      int   d = 10;

      cout << b << endl;
      *c = 5;
      cout << b << endl;
      c = &d;
      a++;
      b++;
      (*c)++;
      d++;
      cout << a    << endl
           << b    << endl
           << (*c) << endl
           << d;

      return 0;
   }
   

3 5 7 7 12 12

   #include <iostream.h>
     
     char test(int i) {
        cout << "one" << endl;
        return 'B';
     }
     
     int test(int i, float f) {
        cout << "two" << endl;
        return 8;
     }
     
     float test(char c, int i = 3) {
        cout << "three" << endl;
        return 3.14;
     }
     
     int test(float f) {
        cout << "four" << endl;
        return 7;
     }
     
     
     int main() {
       int   x = 1;
       float y = 2.0;
       char  z = 'A';
     
       cout << test(test(y))    << endl;
       cout << test(test(x))    << endl;
       cout << test(test(x, y)) << endl;
       cout << test(test(z, x)) << endl;
       cout << test(test(z))    << endl;
     
       return 0;
     }
   

four one B one three 3.14 two one B three four 7 three four 7