Object-Oriented Programming With ANSI-C (pdf)

110 __________________________________________________________________________
9 Static Construction — Self-Organization
order. In order to avoid trivial but hard to diagnose errors, we should provide a
mechanism which performs these function calls automatically — our programs
should be self-organizing.
One solution is to use a linking technique, for example with the aid of a program
such as munch, to produce an array with the addresses of all initialization
functions and call each array element at the beginning of a main program. A function
main() with a loop executing the array can be part of our project library, and
each program starts with a function mainprog() which is called by main().
Another solution is to let an initialization function return the initialized object. If
the function is locked so that it does the actual work only once we can replace each
reference to a static object by a call to its initialization function. Alternatively, we
can use macros to produce the same effect more efficiently. Either way we can no
longer take the address of a reference to a static object, but because the reference
itself is a pointer value, this should hardly be necessary.
9.6 Exercises
The Class() macro is a more efficient, portable solution for automatic initialization of
class descriptions than using functions. It is implemented by changing reports,
class definitions, and application programs just as described above.
munch may have to be ported to a new system. If it is used together with the
Class() macro, for a production system we can remove the conditional from the
macro and initialize all class descriptions with munch. How do we initialize things in
the right order? Can ooc be used to help here (consult the manual in appendix C
about option −M for occ)? What about cast() in a production system?
All class descriptions should first show up in calls to cast(). We can define a
fake class
typedef const void * (* initializer) (void);
% Class ClassInit: Object {
initializer init;
%}
and use statically initialized instances as ‘‘uninitialized’’ class descriptions:
static struct ClassInit _Point = {
{ MAGIC, 0 }, /* Object without class description */
initPoint /* initialization function */
};
const void * Point = & _Point;
cast() can now discover a class description with a null class description pointer,
assume that it is a struct ClassInit, and call the initialization function. While this
solution reduces the number of unnecessary function calls, how does it influence
the use of cast()?