Mac Forum / Programming / Mac Programming / January 2006

Ummm... I meant "community" ... :-/

-- Uli
http://www.zathras.de

Thank you. Yes, you are quite right. gnustep is an open source
implementation of a framework similar to Cocoa. Objective-C is a
language, supported by the GNU compiler.

Since the original poster is familiar with MFC, he might consider
dividing his program into two sections: a User Interface done in
Objective-C++, where his U.I. objects hold pointers to C++ objects that
do the real work. This 'engine' could be basically C++, using
objective-C constructs only as necessary to call back into the user
interface layer of the system. And using the <http://boost.org/> or
std::tr1:: smart pointer classes scoped_ptr, auto_ptr, shared_ptr, and
weak_ptr for memory management in places where a strict discipline of
single-ownership isn't sufficient.

scoped_ptr makes sure that objects allocated on the heap are cleaned up
then the only reference to them goes out of scope.

auto_ptr lets functions return objects allocated on the heap, but
guarantees that those objects will get disposed if the return value
isn't assigned to anything.

shared_ptr manages reference counts for objects that might be owned
equally by a number of different containers, where it disposes itself
when the last one goes away.

weak_ptr manages references to shared objects where you don't want a
share in the ownership, you just want to be informed if you are holding
a weak pointer and the underlying object goes away.  For example, in a
word processor with an asynchronous spelling checker that is working on
paragraphs of a document. Close the document, the paragraphs, owned by
the document go away, even though the spelling checker thread is still
running. The spelling checker discovers its got a dead weak pointer, and
stops.

That way he could take advantage of C++'s RIRA idiom (Resource
Initialization is Resource Allocation (where objects are allocated in
initialized in constructors, which throw on failure)), and C++'s
guarantee that destructors get executed when you leave a block even if
you leave because something throws an exception.

That way he could take advantage of C++'s standard library which
separates containers from algorithms using iterators to glue the two
together. The Boost Graph library has some very sophisticated graph
algorithms, that can work on many different kinds of representations

I used to be a fan of garbage collection, but not any more. It is kind
of like getting to the moon by climbing a tree: you make a lot of good
early progress, but pretty soon you have to go back to your funding
agency and ask for a bigger tree. Yes, during the early stages of the
project, you don't have to worry about when objects are deallocated, but
when the times comes that you _do_ have to worry, because your program
is a success, for example, the problems are buried in layers of
asynchrony and nondeterminism. Much better to think about the issues up
front and get them right while the program is still small. Much better
to train yourself to write correct programs, than it is to use a system
that is forgiving of your mistakes until it is extremely expensive to
fix them.

If you have an existing ANSI C corpus, you can leverage that. If it's
clean, it should build with little or no trouble.

G

Just forget about Carbon! (Some Carbon functions are handy, but you can
always call them directly from within your Cocoa/Objective-C code if you
need them. Remember: any valid C-code is also valid Objective-C code).
If you are a 1-man outfit you'll be much more productive with Cocoa.
(for custom DB, see if the Cocoa CoreData framework suits your needs).

Cocoa is easier to develop, has clean object-orientation, and is
favoured by Apple. New stuff is added to Cocoa first.

patrick