Introduction

Last day, we talked about two different ways that you could try to add object orientation to C:
- View classes as structs with functions pointers, bindings, and syntactic sugar
- View classes as functions with static members acting as fields, using a message parameter to the function to say what method to invoke. We didn't finish describing this approach.
- C++ takes the first approach. The second approach is more akin to Objective-C.
The point of this exercise is to try to understand the semantics of object-orientation in terms of our understanding of a procedural language.
We could take this a step further and map our understanding down to assembly.
For the first approach, one would expect to see separate functions for each method with name mangled labels to remember which class they came from.
This would also allow us to see how C structs are implemented in code. For locally defined struct used in local variables, thing get implemented write on the stack. For globally defined structs, we need to create code sections essentially implementing the struct symbol table.
We will describe now the second approach in more detail before saying what we'd expect of the assembly.

Message Passing and OO

Often complex systems are modeled as a collection of actors who communicate with each other.
This often arises for instance in networking where one has two machines communicating, in parallel processing where one might have communicating processors, in OO where we might have object that invoke each others methods.
You can think of the communication as calling some function and having a slot in that function that says the message type and then using maybe stdarg.h to pass some number of additional arguments along with this message:
```
void my_class(int msg_code, ...);
```
But how do we remember the state of our actor??

Preserving State the Fortran Way

Since Fortran, you can preserve state in a functions.
In C, this is done using the keyword static.

So we have the following skeleton:

void my_class(int msg_code, ...)
{ static int my_field1; //... other fields
   switch(msg_code) {
        case method1:
        break;
       ...
        default:
  }
}

But Every Class Would be a Singleton

The problem with the above is one function can only store one objects worth of data.

How can we get around this?

void my_class(int *object_id, int msg_code, ...)
{ static int *my_field_1;
   switch(msg_code) {
     case NEW:
        //my_field_i is a dynamically allocated array
       // managed by NEW and DESTROY
       // object_id's value is one index in this array.
  } 
}

It is painful for the compiler to actually have to reduplicate the code to manage creating and destructing for each class we define.
Instead, we define a generic function msgSend which also takes as an argument the particular class that is being dealt with.
So if you look at the assembly you should see something that plays this role.

Some Differences With Between Message Passing and the ADT Style

Notice in the ADT style, for each new class we have essentially created a new type.
In some languages such as Smalltalk, everything is an object, and has its own type.
In the message passing way, we have new functions for each class, but its static members aren't really organized into a new type.

Objective-C

Is there a language that actually takes the message passing approach?
Yes. Objective-C
Objective-C was created by Cox and Love in the mid-1980s.
It was popularized by NextStep Corp, which was later bought by Apple.
Objective-C is used to program Mac's, iPhones, etc. There is also a GNU version.
It is an extension of C. So C programs are Objective-C programs.

The Basics of an Objective-C Program

Header Files use the extension .h
Implementations use the extension .m

A .h file typically might be used to define an interface of a class. This might have the format:

@interface classname : superclassname {
   int my_field; 
    // instance variables can be any C type or  the generic id type.
}
+classMethod1; // + means class method; - means instance method
+(return_type)classMethod2;
+(return_type)classMethod3:(param1_type)parameter_varName;
-(return_type)instanceMethod1:(param1_type)param1_varName :(param2_type)param2_varName;
-(return_type)instanceMethod2WithParameter: (param1_type)param1_varName andOtherParameter:(param2_type)param2_varName;
@end

Implementation Files

To implement the functions you use an implementation file and the syntax:

@implementation classname
+classMethod {
    // implementation
}
-instanceMethod {
    // implementation
}
@end

Invoking Methods

A call obj.method(parameter); in C++ might look like [obj method:parameter]; in Objective-C.

You can have multiple parameters:

[obj method:parameter1 paramName2: parameter2]

To instantiate a class you can send either the new message or instantiate in two steps:
```
    MyObject * o = [MyObject new];
    MyObject * o = [[MyObject alloc] init];
```
You can override the init method of your class to make a new constructor.

Example Objective-C Program

// Interface File
#import <objc/Object.h>

@interface MyHello : Object {
   int myNumber;
}
-setNumber:(int)aNumber;
-sayHello;

@end

Example Program cont'd

// implementation file
#import <stdio.h>
#import "MyHello.h" 
@implementation MyHello
-setNumber:(int)aNumber {    myNumber = aNumber;
} 
-sayHello{    
   printf("Hello! %d\n", myNumber);
} 
-(id) init { //self is like this in Java
    self = [super init];
    if (self) { myNumber = 0; }
    return self;}  
@end

Objective-C Example Last Part.

#import "MyHello.h"
int main(void){
MyHello *hello = [MyHello new];  
[hello setNumber:10]; 
   //set the number to echo
[hello sayHello];
return 0;
}
/* To compile in gcc could type:
gcc -x objective-c -Wno-import main.m MyHello.m -lobjc   */

iPhone/Android Class Plug

Next semester, I will be teaching a class on application development for both the iPhone and Android platforms.
The iPhone part of the course will make use of Objective-C.
The Android part of the class will be in Java, making use of Google's Android SDK.

More OO

Outline