Lecture 3:
Classes and Objects

What are these things? Which are values? types? objects? handles? classes? (Note: people use different formal definitions for these notions.)

• int and int[] (''data type'' --- what is it?)
• 3 (''primitive value'' --- what is it?)
• new int[5] (handle to a newly allocated array) and int[5] (template for array allocation)
• int[] r = new int[5] (variable holding handle to newly allocated array)
• This example is from C:

  struct BankAccount {  // template for allocating a "frame" (namespace) of vars
     int acct_number;
     char[50] *name;
     float balance;
  };
  BankAccount s;   // allocates a frame and names it  s
  s.acct_number = 999;
  

• This example is from C#:

  class BankAccount {
    public readonly int acct_number;
    public readonly string name;
    private float balance;
  
    public BankAccount(int num, string n) { acct_number = num;  name = n; }
    public void deposit(float m) { if (m>0){ balance = balance + m; } }
    public float getBalance() { return balance; }
  }
  
  class Program {
    static BankAccount master_acct = new BankAccount(000, "Bank");
  
    public static void Main() {
      BankAccount customer = new BankAccount(999, "Edward");
      ...
  }
  

A class is a template for allocating a frame (namespace) and defining functions (methods) that access the frame. You won't get into too much trouble by pretending that a class is a ``user-defined data type.'' (For most people, a "data type" is a collection of values and some operations that compute on the collection.)

An object is the frame ("namespace") that is allocated when you construct a new instance of a class template. A static variable or method is a single instance that is "pre-declared" (and not constructed).

3.1 Computer storage layout

+-----------------------+------------------+------------------------+
| operating system code | web browser code | ... ( free space ) ... |
+-----------------------+------------------+------------------------+

+-- ... --+------------+-------------+----------------------------+------------------------------------------+
| OS etc. | C# program | static area | stack --> (empty) <-- heap | ...(remaining free space)... |
+-- ... --+------------+-------------+----------------------------+------------------------------------------+

When a new object is allocated, it is allocated in the heap part.

When a method is called, its parameter-argument bindings and its local variables are saved in a new frame that is allocated "on top of" the stack. (When the method finishes, the frame is "popped" from the stack.)

In fact, a frame and an object are the same thing, but they are allocated at different places.

3.1.1 Example with static vars and an array object

===================================================

using System;
public class Prog {
     public static int size = 4;
     
     public static void Main() {
       int[] r = new int[size];
       r[0] = size;
       int j = size - 1;
       r[j] = f(j);
     }

     public static int f(int x) {  
       //***
       return size + x;
     }
   }
}

===================================================

VS does not show the difference between the stack and the heap! Also, it is not so good at displaying static variables.

3.1.2 Example with a class

===================================================

using System;
public class Ex2 {
   public static void Main() {
     Clock c = new Clock(80);
     Clock d = new Clock(90);
     c.tick(2);
     Clock e = d;
     d.tick(3);
     Console.WriteLine(e.getTime());  Console.ReadLine();
   }
}

class Clock {
    static int count = 0;
    private int t = 0;
    public Clock(int start) { t = start; count = count + 1;
    }
    public void tick(int n) {
        ///***
        t = t + n;
    }
    public int getTime() { return t; }
}

===================================================

Notice that the methods for Clocks are saved in the Code area, and not in the objects. (Doing the latter would be correct but a waste of storage.) This little optimization causes a complication --- see below.

Now run VS on the example and break at point //*** to see how VS presents the storage layout. Match it to the above diagram.

Visual Studio is not so good at showing the handles (storage-location numbers) of objects, and it does not show that c and e are names that share (alias) the same object. Be careful!

Now, consider the code in tick:

t = t + n ;

d.tick(3);

public void tick(Clock this, int n) {
  this.t = this.t + n;
}

This setup lets the code for tick work correctly with either object c or object d (or object e).

3.2 Object diagrams for design

When an object diagram is used for design, only the Heap portion is drawn, and details about fields within objects can be omitted.

Here is an example: We hope to build a database of bank accounts and customers, where a customer might own multiple bank accounts. The data base also has a global clock and some main controller that enforces access rules to the customer and account records. Here is an object diagram that shows how the Heap might look once the system is executing:

Another example: we are designing a card game that uses Cards, a Deck to hold the cards, and a Hand-of-Cards for each Player. Here is a design expressed as an object diagram:

There is more to say about this next time.

Exercise