Objective-C: the More Flexible C++

An introduction to Objective-C for programmers familiar with C++ or any other OOP language.

The only way to tell an object to do something is to send it a message. The well known metaphor of objects as active actors can be used. An actor communicates through a message to another to request that she do something. The receiving object is called the "receiver" of that message. The receiver will determine the concrete behavior. It will make a big difference if you send "I love you" to Catherine instead of Katia. Different receivers cause different implementations.

[receiver message];
[receiver message: arg1];

Arguments are used after colon-terminated message selectors.

If a message is declared as -message, it can be sent to objects. A leading plus sign (+) means that the message can be sent to class objects. The default return type for methods is "id". If a method has nothing useful to return, it returns "self", which is a pointer to the object to which the message was sent (similar to "this" in C++).

By implementing the method -doesNotUnderstand:

-doesNotUnderstand: msg { [msg sentTo:delegate]; }

an object can forward messages to another object ("delegate"), including messages that return C structs, doubles, chars and so on.

Classes and Inheritance

A class is used to produce similar objects, called instances of the class. Classes are used to encapsulate data and methods that belong together. Methods are the operations that Objective-C applies to data and are identified by their message selectors.

Objective-C supports polymorphism: several classes can have a method with the same name.

Inheritance is used for code reuse. 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.


Compile-time and link-time constraints are limiting because they force issues to be decided from information found in the programmer's source code, rather than from information obtained by the running program. Such static languages usually refuse to introduce new modules or new types during runtime. Objective-C makes as many decisions as possible at runtime:

  • Dynamic typing: waiting until runtime to determine the class of an object.

  • Dynamic binding: determining at runtime what method to invoke--no need to bother about what is done when. This allows it to change the components of a program incrementally.

  • Dynamic loading: program segments are not loaded into memory until they are actually used, thereby minimizing the system resources required for an instance of a program.

If your program offers a framework for others to use at runtime, you can discover what they have implemented and load it at runtime as needed.

Objective-C programs are structured through inheritance (how objects relate by type) and the pattern of message passing (explains how program works).


As the name implies, object-oriented programs are built around objects. Objects are the root of the Objective-C family tree.

id is an object identifier that is a distinct data type. It is a pointer to an object (in reality a pointer to an object's data--its instance variables). The actual class of the Object does not matter because Objective-C does runtime binding.

nil is the null object. The id of nil is 0. Other basic types of Objective-C are defined in the header file, objc/Objc.h.

Every object also carries an is an instance variable that identifies the object's class (what kind of object is it?). This allows objects to be typed dynamically at runtime. isa also allows objects to introspect themselves so they can find out what methods they have.

Usually, you create objects with a call to alloc:

id MyRect;
myRect=[Rectangle alloc];

alloc allocates and clears memory for the instance variable. Initialization typically follows allocation immediately.

myRect=[[Rectangle alloc] init];

Here is an extended example of the lists.

#import <objc/Object.h> 
@interface List : Object 
  int list[100];          // These are instance variables.
  int size;
/* Public methods */
- free;
- (int) addEntry: (int) num;
- print; 
#import "List.h" 
@implementation List 
+ new   
  self = [super new];
  [self resetSize];
  return self;
- free
  return [super free];
- (int) addEntry: (int) num
  if (size<100)
    list[size++] = num;
  return size;
- print
  int i;   
  printf("         \n");
  for (i = 0; i < size; ++i)
    printf ("%i ", list[i]);
  return self;                // Always return self
                              // if nothing else makes sense.
- resetSize
  size = 0;
  return self;

List2.h, below, inherits from the above Lists. -doesNotRecognize is the standard method that gets called if a class does not have the required method. magicMethod in main.m does not exist so doesNotRecognize gets called. This allows for an easy way to create Delegatorpatterns or to use Proxy-setups.

#import <objc/Object.h> 
#import "List.h"
@interface List2 : List  // List2 is a subclass of List
- free;
- (int) sum;
- doesNotRecognize: msg;
#import "List2.h"
#import "List.h"
@implementation List2 : List
- (int) sum
  int i=0;
  int sum=0;
  for (i=0; i<size; i++) 
  return sum;
-doesNotRecognize: msg
    printf("no clue!\n");
    return self;
import <objc/Object.h>
#import "List.h"         
#import "List2.h"
main(int argc, char** argv, char** env)
  int i;
  id list, list2;        // id is a general data type for objects.   
  list = [List new];     // create an instance of class List.
  [list addEntry: 5];    // send a message to the object list
  [list addEntry: 3];
  [list print];
  [list free];           // get rid of object
  list2 = [List2 new];
  [list2 addEntry: 6];
  [list2 addEntry: 4];
  printf("\nsum: %d\n",[list2 sum]);
  [list2 magicMethod];


Comment viewing options

Select your preferred way to display the comments and click "Save settings" to activate your changes.

Re: Objective-C: the More Flexible C++

dankelley's picture

Some thoughts from a scientist who also dabbles in software creation:

my 2 cents Canadian (not much in othe terms, lately) worth...

Some years ago, I wrote a pretty large (10^4 lines) open-source code

in C. It became apparent that it would help for this code to have

parts that were more object-oriented, and so I read a bit and decided

to convert those parts.

During this work, I learned that objC is quite beautiful. By that, I

mean that the code, and the logic it inspired, was elegant to the eye,

in the way that some mathematics proofs can be.

But one day I realized that none of the folks using this code knew

objective-C, whereas many of them knew C++. Since this was a shared

program, I wanted my users to be able to contribute to the work. And

so I started the process of converting the objective-C into C++. That

was not much fun, partly because the syntax is different and partly

because C++ seems not to inspire the writing of elegant code (or,

better stated, it seems not to inspire the construction of elegant


Why is this, exactly? I'm not sure. At first I thought my distaste

for C++ might be just a love of the old. But, now I've been using C++

for years, and I can read/write it much more easily than objective-C,

and I still feel the same way.

In summary, the advantage of objective-C seems to be that it inspires

an elegance of expression. The disadvantage is that fewer people can

read your code.

Of course, all of this may be moot, since it's my

understanding that many students are learning Java before they learn

any of the C dialects. Maybe I'm getting too old to keep up ... I

just get used to Perl and Python comes along like a knight in shining

armor, and before I learn it, I hear that now Ruby rules!


Re: Objective-C: the More Flexible C++

Anonymous's picture

You're right. Obj-C done right is MUCH more elegant than anything else.

Of course, you have to get into the "mood" to do it right. Just applying the "old habits" (C++ etc.) won't work.

Where Objective-C shines is that it leads to truly reusable code. Just comparing the number of classes in a typical C++ library and within Objective-C shows that.

This is not surprising at all: most C++ or Java windowing libraries (like PowerPlant on Mac, MFC on Windows) are anyway just bad copies of the NextStep classes. Their quality only differs how much thought they put into the classes to reassemble the functionality of Objective-C in the choosen language.

so - why not choose the original first?

Learning the syntax is something like 2 days for a C programmer. The tough part is getting the own classes right. But once its understood, there is nothing like it anywhere.

I've written for 10 years in C and C++ and it was always messy and at the end no fun at all. After switching to Obj-C the only thing I regret is not buying a NextStep Station in the 90ies...


Objective-C---more than just games

WillAdams's picture

Macromedia FreeHand (v4) started as Altsys Virtuoso on NeXTstep.

Improv--Although there was an Improv 2 for Windows, it was never quite as nice

as Improv for NeXTstep (which also fell far short of where it ought to've

been), but there's still no widely available spreadsheet available now which

handles 3D data so elegantly AFAIK.

Then, one could compare the programs which are all but without peer, for

example TIFFany (PhotoShop on steroids), or PasteUp.app (developed almost

single-handedly by Glenn Reid in roughly a year). Or, MCI's Friends and Family

database system (they liked it so much, they bought the company!)

NeXTstep is also the premiere platform for using PostScript directly and

interactively---Alan Hoenig praises it in his book _TeX Unbound_

SoftMagic, www.softmagic.co.kr is an incredible product.

And of course, there's WebObjects....

Lastly, Tim Berners-Lee used NeXTstep (he crafted a thing called worldwideweb.app---guess what it

grew into)


Re: Objective-C: the More Flexible C++

Anonymous's picture

Hey, you cannot blame C++ for introducing new keywords and propose a language that overloads every special character on the planet :)

I dont want to say that Objective C is bad or something. But don't try to make a thing better by complaining about another thing.

Beside that, C++ is not only "C with Objects". It has many other useful features, like templates or references. Maybe it would be a good idea to think about mixing C++ and Objective C, creating a "Objective C++" that combines Objective C's runtime system with all the C++ features (and the more popular syntax of C++). As you can see, I am not a proponent of the 'make a language as simple as possible' school, but I rather prefer the 'add every single feature that can not be implemented in a lib, because every feature helps the programmer who works 100h a week in the damn language' school...

Re: Objective-C: the More Flexible C++

Anonymous's picture

Objective-C++ already exists! NeXT extended Objective-C in this way to leverage C++ into NeXTSTEP applications (if the solution already exists in C++ why not use that). It turns out that Objective-C++ is probably only useful for that purpose, the features in C++ have a heavy cost in readability and ease of use, so Objective-C++ isn't used much. Objective-C turns out to prove that K&R were right to keep C a small language. :-)

Re: Objective-C: the More Flexible C++

Anonymous's picture

As you can see, I am not a proponent of the 'make a language as simple as possible' school, but I rather prefer the 'add every single feature that can not be implemented in a lib, because every feature helps the programmer who works 100h a week in the damn language' school...

And it is thinking like that to cause C++ compilers to never be able to totally implement the C++ language specifications. The compiler makers have a hard time trying to implement these "features". I always get frustrated to write a program using valid C++ and it compiles and runs fine on one platform and try to compile it on another(VC++) and have either totally rewrite that part of code or do some conditional compilation that makes the code hard to read. I like C++ and wish a few of the very useful features like namespaces would be added to Objective-C. I am totally against templates being added since it is against the philosphy of a dynamic OO language.

A simpler language allows you to move on and start writing code to do some work. I was able to learn Objective-C in a few days and I understand the entire language. I been programming in C++ for 5 years and I still do not know the language.

Re: Objective-C: the More Flexible C++

Anonymous's picture

> I was able to learn Objective-C in a few days and I understand the entire language.

Just Understand the language is not enough, Apply them practical will tell.

> I been programming in C++ for 5 years and I still do not know the language.

Are you work as a professional programmer for a competitive company or non professional just writing some simple app as hobby or in goverment org that use & waste tax-payer money ?

Nowaday, all OOP similar to C++, include JAVA, C#, VB.NET etc. If you cannot understand C++, you cant understand thiese language as well.

If you are a professional programmer, esp in competitive company, you are already fired (for failed to know the language).

Other comment is, C++ Template (Now C#/VB dot.net also support similar features called "generic") is "good to have", but is NOT "must have", it can improve the reusability and flexibilty very much, esp like map, list, stack etc.(standard template library)
Nevertheless, You do NOT need to explicitly write C++ template to qualify as "C++ programmer". Many professional C++ programmer never write their own template. (template is not so easy to read, but very easy to use).

Many developer likes to make use of some language features just purely because of "the language have this features - I MUST use it", or to show-case there are the pro. , without considering practically, case by case suitability and portability. (ie, "good to have" vs "must have").

Not using template, does not disqualify you as C++ Programmer, But Not even have a basic understand of it, may disqualify you as C++ programmer).

What language to use, and their understanding of the language, depend on the programmer computer-science knowledge also, of-course we cannot expect, for someone study archeology to code in C++. But for those have strong Computer-Science background, C++ is just as easy as A B C.

BTW, I self study OOP generally, C++ specifically. (my school deos not not teach us C++ at that time). I can "understnad" it in few days also, cannot imaging there is someone cannot understand it after 5 years !

Re: Objective-C: the More Flexible C++

Anonymous's picture

Objective C++ already "exists"...

Re: Objective-C: the More Flexible C++

Anonymous's picture

And this does not look like C.

No wonder people adopt C++ instead of Objective-C.

Re: Objective-C: the More Flexible C++

Anonymous's picture

In my opinion, part of C++'s problem is that it looks TOO MUCH like C. This, I think, encourages confusion among beginners and the tendency to write C code, not OO code, with C++.

IMHO, a method call is inherently different from a function call - especially in a dynamic system like ObjC, and should have its own notation distinct from that of a function call.

Likewise, an object is inherently different from a structure, and the notation should be different. Etc.

I much prefer ObjC's [foo bar:1 with:me];

syntax, because it is quite clear that this is an OO construct, and different from all the C code that might surround it.

Without OOP knowledge, not look too much like.

Anonymous's picture

> In my opinion, part of C++'s problem is that it looks TOO MUCH like C. This, I think, encourages confusion among beginners and the tendency to write C code, not OO code, with C++.

Programmer without OOP concept and skill, will write in structured manner given whatever OOP language to them.

for eg, if the code is written by non OOP/C++ programmer, there actually write in 'C' only, wrapped, or saved in .cpp or .cc files.

.cpp or .cc save file does NOT mean it is C++ code. keep in mind.

For those programmer, There are not C++ beginners, but OOP beginner or totally have no idea of what is OOP.

If you given them Obj-C capable compiler, there will also write their code in C only code, wrapped / saved in .m files - nothing to do with "look too much like".

Re: Objective-C is definitely superior to C++

Anonymous's picture

I totally agree with you...

Who does not agree with the title either does not know the language or is a moron (no pun intended)

On the other hand, I believe Objective-C lacks a couple of important features that C++ has (namespaces and templates among them), but I found that it is still an excellent language even without those...


You can always mix both languages with Objective-C++

Once I read an article by Tim Sweeney (creator of UT) where he analysed programming languages (or something like that)... he stated that in the future, languages will have features to make class hierarchies "extensible" (I can't remember the exact words)... Obj-C is already capable to do that and with trivial effort (and dynamically: you can "override" any class you find with your own version)

Re: Objective-C: the More Flexible C++

Anonymous's picture

why don't your use [[List alloc] init] to create an object? You used [List new]. But you said:

Usually, you create objects with a call to alloc:

Very confusing.

Re: Objective-C: the More Flexible C++

Anonymous's picture

new is a short cut.

[Object new]

is equivalent to

[[Object alloc] init]

Re: Objective-C: the More Flexible C++

Anonymous's picture

new is just a "shorthand" method used in GNUStep:

- (id) new


return [[self alloc] init];


Method new might not actually be (not sure) the one above but surely it does the same as above (conceptually)

Geek Guide
The DevOps Toolbox

Tools and Technologies for Scale and Reliability
by Linux Journal Editor Bill Childers

Get your free copy today

Sponsored by IBM

8 Signs You're Beyond Cron

Scheduling Crontabs With an Enterprise Scheduler
On Demand
Moderated by Linux Journal Contributor Mike Diehl

Sign up now

Sponsored by Skybot