Please see text links at bottom of page for navigation

Objective-C

Overview

Objective-C is an object-oriented extension to the C language. It is C with a small number of extensions.

Although the differences can fade into shades of grey, Objective-C is different from C++. C++ is traditionally associated with the Simula 67 school of object-oriented programming where Objective-C has SmallTalk roots. In C++, the static type of an object determines whether it can receive a message. In Objective-C the dynamic type of an object determines whether it can receive a message. The Simula 67 format is more structured and allows problems to be detected earlier when a program is compiled. The Smalltalk approach delays it's typing until runtime and is touted as a more flexible alternative.

This flexibility extends the language into three separate areas: Dynamic Typing, Dynamic Binding and Dynamic Loading.

Dynamic Typing

As opposed to other languages, Objective-C delays the typing of language objects until a program is executed at run time. The method name, type and argument information as well as class variable instance information are available to provide the essential support for Dynamic Binding. This might by likened to the System Object Modules (SOM) and it's Interface Definition Language (IDL) that Apple has been using for it's more recent object-oriented system additions.

Dynamic Binding

Methods and classes may be added or deleted at run time. The resulting list of objects are bound together during run time using the Dynamic Typing information. This provides the flexibility to develop programs in pieces using stepwise refinement to create an initial version of a program and then later during the maintenance phases of a programs life to incrementally change the components of a program.

Dynamic Loading

Finally, program segments are not loaded into memory until they are actually used thereby minimizing the system resources required for an instance of a program. In Objective-C all of this is bound into the language and it's run time. Objective-C is possibly one of the best blends of traditional system programming language features and object-oriented programming features.

History

Objective-C was developed by Brad J. Cox to add object-oriented SmallTalk-80 based extensions to the C language. A GNU version was written by Dennis Gladding in 1992 and the second version soon thereafter by Richard Stallman. The current GNU version is derived from the version written by Kresten Thorup when he was a university student in Denmark in 1993. Kresten transported that version to NeXT when he joined the firm later that same year.

Objective-C Components

Objective-C is organized as a series of object-oriented additions to the C language. It is important to remember that it is the ANSI C language at its core. In a typical Objective-C program, segments of traditional C are organized into strips of code and associated data which are executed under tightly constrained conditions. This new framework for C has a well defined family of components that must be understood for the overall program to make sense. The members of the Objective-C family are:

Objects
Objects associate data and operations. Objects are the root of the Objective-C family tree.

Methods
Methods are the operations that Objective-C applies to data.

Messages
Messages are the way one instance of a method requests another method to perform and operation. For example [myrect display] asks the myrect method to perform the display operation.

Classes
Classses are how objects are defined. Classes contain the prototype object variables and methods. Classes inherit variables and methods from a higher level class called a super-class. A class that inherits some or all of the methods and variables is a sub-class. In Objective-C all classes are a sub-class of a primal super-class called Object.

Protocols
Protocols are ways to inherit part of a super-class or to extend a super-class.

Categories
Categories are ways to declare Methods that can be implemented by any class.

Remote Messages
Remote Messages support the distribution of objects into different threads of execution and across different computers. Remote Messages are the heart of distributed application progressing.

Multi-tiered distributed applications are one of the hallmark features of the OpenStep architecture.

Persistance
Objects and their data can be allowed to persist after the creating instance of an object has completed it's execution. This is an important and advanced feature of the OpenStep system.

In traditional programming languages a function is called to perform an operation on a data object. In Objective-C and other object-oriented languages, a message is sent to an object asking it to perform one of its methods on itself.

A Practical Analogy

Many file systems are organized into standard primitive operations such as:

Open - open or create a file
Close - close a file
Read - read data from a file
Write - write data to a file
Ioctl - perform file system specific operations

The Open call usually returns some sort of identifier that is used in subsequent Read, Write and Ioctl operations. The identifier is valid until a Close call is made. In an object-oriented environment, the class might be named FileSystem, the methods would be Open, Close, Read, Write and Ioctl. The object would be the file identifier that is returned by the Open call and binds all subsequent calls to a single body of file information.

Objective-C Example

This example is also take from Gerrit Huizenga's course notes from an object-oriented language course taught at Purdue University. The URL for the course notes and other reference information are contained later in the reference section.

In Objective-C program segments are defined by an interface and an implementation. These are by convention separated into two files. The interface file is named with a '.h' extension and the implementation file is named with a '.m' extension.

Interface Definition

In Objective-C the interface to a class is defined using the @interface and @end pair of language statements.

@interface Stack : Object

Defines the Stack class as a subclass of the Object super-class. This declaration is followed by the instance variables used to implement the object. Each instance of a class has it's own copy of these variables.


@interface Stack : Object
{
        StackLink *top;
        unsigned int size;
}

Defines the Stack class with instance variables top and size;

Following this definition is a list of the names of the methods that implement this class.


        - free;
        - push : (int) anInt;
        - (int) pop;
        - (unsigned int) size;
@end

Defines free, push, pop and size methods for the Stack class. The declaration is terminated with an @end statement. Method names contain a colon to separate the name of a method from its arguments. A colon is also used to separate arguments. For example:


        - push: (int) first and: (int) second;

Defines the push method with integer arguments first and second. The precise name of the method is push:and:. Any parameter type used in C language function parameter "typecast" notation is valid in method definitions. The return type of a method is also specified using typecast notation. If no return type is specified, then the method is assumed to return a pointer to an object.

At first glance the alloc method would naturally be another method that might be included with the Stack class. We will see below that every class has a means to create an instance or allocate itself.


#import <objc/Object.h>

@interface Stack : Object
{
        Stacklink *top;
        unsigned int size;
}
- free;
- push : (int) anInt;
- (int) pop;
- (unsigned int) size;
@end

is the completed interface definition for the Stack class. It is stored, by convention in the file Stack.h.

Implementation

The second component of a class definition is the implementation. Like the interface definition Objective-C uses paired sets of @implementation and @end statements to deliniate an implementation:


@implementation Stack
  .
  .
  .
@end

Defines the Stack implementation. By convention the implementation of a class is stored in a file the ends with a '.m' suffix. In this case the file would be named Stack.m.


#import "Stack.h"

#define NULL_LINK StackLink *0

@implementation Stack
+ new
{
        self = [super new];
        top = NULL_LINK;
        return( self );
}

- free
{
        StackLink *next;
        while( top != (StackLink *)0 )
        {
                next = top->next;
                free( (char *)top );
                top = next;
        }
        return( [super free] );
}

- push: (int )value
{
        StackLink *newLink;
        newLink = (StackLink *) malloc( sizeof(StackLink) );
        if( newLink == 0 )
        {
                fprintf( stderr,"Out of Memory\n" );
                return( 0 );
        }
        newLink->data = value;
        newLink->next = top;
        top = newLink;
        size++;
        return( self );
}

- (int) pop
{
        int value;
        StackLink *topLink;
        if( size == 0 )
                value = 0;
        else
        {
                topLink = top;
                top = top->next;
                value = topLink->data;
                free( topLink );
                size--;
        }
        return( value );
}

- (unsigned int) size
{
        return( size );
}


@end

The implementation defines methods new, free, push, pop and size.

Super-class References

Bracketed statements such as [super new] and [ super free ] refer to the super-class methods new and free allowing them to process at particular points of the sub-class.

The Notion of Self

Self is a special variable which is a pointer to the object which received a message which invoked the currently executing method. It is a way to reference the receiver object of a message. Also remember that if a method does not specify the type of it's return value, the default is to return a pointer to an object. This means that barring any other sensible returns, methods should always return self. Doing this provides a means for super-class and sub-class implementations to share processing and return values.

Factory Objects

Objective-C automatically creates a factory object for each class. There is exactly one instance of a factory object at run time. The name of the factory object is the same as the name of the class. The principal use of a factory object is to provide a means to create instances of a class:


id myStack;
myStack = [ Stack new ];

Factory methods are defined with a '+' instead of a '-' character.


+ new
{
        self = [super new];
        top = NULL_LINK;
        return( self );
}

Factory objects are not instances of a class and therefore do not have access to the instance variables. So factory objects typically redefine self before accessing instance variables.

Referencing a Class

Objective-C is ANSI C and additional abilities to define classes, create instances of objects and send messages to objects. Two fundamental types have been added to the language:

id - a pointer to an object

sel - a messages

Both variables of type id and sel are valid parameters that can be sent in messages or passed to a C function.

Messages are sent to a class with a SmallTalk-like syntax:


        id s;
        int i;
        s = [ Stack new ]; // send "new" message to factory
        object Stack [s push:97 ]; // send "push" message w/param 97 to s 
        i = [ s pop ]; // send "pop" message to s

In the Objective-C implementation, methods access and modify instance variables to perform their operations. Methods perform all operations normally thought of in C. In addition, they have access to the full capabilities of Objective-C message passing with the notions of self, super-class, parameters and instance variables.

An object might send a message to self to accomplish parts of it's operation. Here is the stack:and: method implemented by using paired stack push operations and self:


- push: (int) first and: (int) second
{
        [ self push: first ];
        [ self push: second ];
        return( self );
}

Again notice that self is returned to facilitate super-class and sub-class integration.

References

Web

Gerrit Huizenga Objective Oriented Programming Course Notes
http://www.cs.indiana.edu/classes/c304/oop-intro.html

Online Objective-C home page
http://www.slip.net/~dekorte/Objective-C

GNUStep home page
www.gnustep.org

Objective-C Frequently Asked Questions Web page
http://www.cis.ohio-state.edu/hypertext/faq/usenet/Objective-C/top.html

Objective-C News Group
news:comp.lang.objective-c

Rhaposody Documentation: The Objective-C Language
http://developer.apple.com/techpubs/macosx/macosx.html

Books

Brad J. Cox, Andrew J. Novobilski: Object Oriented Programming: An Evolutionary Approach. Addison-Wesley Publishing Company, Reading, Massachusetts, 1991. ISBN: 0-201-54834-8 (Japanese: 4-8101-8046-8).

abstract: The first book on Objective-C, which actually is a book on object oriented system development using Objective-C.

Lewis J. Pinson, Richard S. Wiener: Objective-C: Object Oriented Programming Techniques. Addison-Wesley Publishing Company, Reading, Massachusetts, 1991. ISBN 0-201-50828-1 (Japanese: 4-8101-8054-9).

abstract: Includes many examples, discusses both Stepstone's and NeXT's versions of Objective-C, and the differences between the two.

Timothy Budd: An Introduction to Object-Oriented Programming. Addison-Wesley Publishing Company, Reading, Massachusetts. ISBN 0-201-54709-0 (Japanese: 4-8101-8048-4).

abstract: An intro to the topic of OOP, as well as a comparison of C++, Objective-C, Smalltalk, and Object Pascal

Simson L. Garfinkel, Michael K. Mahoney: NeXTSTEP Programming Step ONE: Object-Oriented Applications. TELOS/Springer-Verlag, 1993 (tel: (800)SPR-INGE).

abstract: It's updated to discuss NeXTSTEP 3.0 features (Project Builder, new development environment) but doesn't discuss 3DKit or DBKit.

NeXTSTEP Object Oriented Programming and the Objective C Language. Addison-Wesley Publishing Company, Reading, Massachusetts, 1993. ISBN 0-201-63251-9 (Japanese: 4-7952-9636-7).

abstract: This book describes the Objective-C language as it is implemented for NeXTSTEP. While clearly targeted at NeXTSTEP, it is a good first-read to get to learn Objective-C.

Articles

`Why I need Objective-C', by Christopher Lozinski.Journal of Object-Oriented Programming (JOOP) September 1991. Contact info@bpg.com for a copy and subscription to the BPG newsletter.

abstract: This article discusses the differences between C++ and Objective-C in great detail and explains why Objective-C is a better object oriented language.

`Concurrent Object-Oriented C (cooC)', by Rajiv Trehan et. al. ACM SIGPLAN Notices, Vol. 28, No 2, February 1993.

abstract: This article discusses cooC, a language based on the premise that an object not only provides an encapsulation boundary but should also form a process boundary. cooC is a superset of Objective-C.

`Porting NEXTSTEP Applications to Microsoft Windows', by Christopher Lozinski. NEXTWORLD EXPO Conference Proceedings, San Francisco, CA, May 25-27, 1993. Updated version of the article available from the author.
Contact info@bpg.com.

abstract: This article describes how to develop Objective-C applications for both Microsoft Windows and NEXTSTEP.