• init, which takes as arguments the initial position and size of the object. init initializes the object, then draws it.
• move, which draws the object in black, modifies the position, then draws it in white. move takes a change in the y and x coordinates as arguments.
• draw, used by init and move. draw takes a color as an argument.

I'll start with a simple data abstraction mechanism, then develop it into a system that supports classes, inheritance, and messages.

The most natural means of creating an object and associating methods with it is to put pointers to the methods (pointers to functions) in a structure along with the data. A structure for an instance of a circle might look like this:

struct {
    int y;
    int x;
    int radius;
    void (*init)();
    void (*draw)();
    void (*move)();
} circle;

To make the class structure more generic, we define an array of pointers to functions, and by convention, define the methods as an index into this array. The code now looks like

/* defines for methods */
#define INIT 0
#define DRAW 1
#define MOVE 2

struct class {
    int nbr_methods;
    void (**method)();
};

typedef struct class CLASS;

struct {
    CLASS *class;
    int y;
    int x;
    int radius; }
circle;

All methods should be aware that obj->data is a pointer to the data allocated on the heap. For a particular class, this data is of an assumed structure type. By casting obj->data to a pointer to a structure, the method can access the object data correctly.

All methods receive the argument arg_ptr, which can be used with the macro va_arg() if there are arguments to the method. See your documentation on stdarg.h.

typedef struct {
    void *data; 
    CLASS *class;
} OBJECT;

I implement inheritance of data structures by having a sub-class allocate more memory than the super-class. The sub-class data consists of the parent-class data followed by the data specific to the subclass.

Another disadvantage is that when writing methods, the programmer must access the data in the object correctly. The pointer to the data in the object structure must be cast as a pointer to the correct structure type.

I'll explain a small subset of the syntax of C++, only what is essential to do object-oriented programming. There are many features of C++ that have nothing to do with object-oriented programming, and the object-oriented programming part of C++ is elaborate, with useful but nonessential features. The subset is:

• Definition of a class, with and without a super-class.
• Definition of a method.
• Declaration of an object.
• Sending a message to an object.

• The data structure of the class.
• The super-class if there is one.
• The methods.

class graph_obj {
public:
    int y;
    int x;
    void init(int y, int x);
    void move(int y, int x);
    virtual void draw(int color){};
};

The class graph_obj doesn't have a super-class. When defining a class where there is a super-class, you follow the name of the class by a colon (:), the keyword public, and the name of the super-class. For example:

class circle : public graph_obj {
public:
    int radius;
    void init(int y, int x, int
radius);
    void draw(int color);
};

void circle::draw(int color)
{
    /* code to draw a circle */
    ...
}

Methods are invoked much as functions are called in C. Sometimes, when writing code for a method, we want to force a method to be invoked for a super-class, and the class for which we are writing the method has a method of the same name as the one in the super-class that we want to invoke. In this case, we can use the scope resolution operator (::) and force the method to be invoked for the super-class. For the init method for class circle, to invoke the init method for class graph_obj, we specify the name of the class, followed by the scope resolution operator, followed by the name of the method.

Sometimes the method to invoke at run time can't be determined because a particular section of code could be operating on many types of objects. In C++, code such as this must be operating on objects of a certain class, or of a sub-class of that class. If you declare a method of a class highest in the class hierarchy virtual, C++ will wait until run time to make the decision of which method to invoke, and will invoke the correct method for the object being operated on. To do this, C++ puts something in the object that indicates which class it is. Resolution of the method to invoke at run time is called late binding.

This is useful when you send messages to pointers to objects, where the pointer could point to one of several classes of objects. It's also useful in a method that serves a class and its subclasses. draw is virtual because the method move (which uses the method draw) in class graph_obj also serves classes circle, double_circle and square.

In C++, each class can have two special methods: the constructor and destructor. Essentially the constructor is called automatically when an object comes into scope, and the destructor is called when an object goes out of scope. For example, if you declare an automatic object at the start of a function, the constructor is called at the time of declaration, and the destructor is called before the function returns to its calling function.

Constructors and destructors are not essential to object-oriented programming. In other systems, programmers make a method specifically for initializing an object when they need one, then send that message to the object after creating it. In the C++ example that accompanies this article, I don't use the built-in constructors and destructors. In both the C and C++ examples, I have a method that initializes the values of the graphical object. I call this method INIT.

In the C example, I use a function that allocates memory for the object before use and frees the memory after use. These functions aren't defined as part of a class and should not be confused with methods.

circle c1;

message(&c1, MOVE, 1, 1);

c1.move(1, 1);

• The object (c1)
• The message (MOVE or move)
• The number of pixels to move in the y and x direction.

Often in C++, when a message is sent to an object of a known type, the compiler resolves the particular method to invoke at compilation time. This is called early binding. In contrast, the function message() in the C scheme presented here resolves the issue of which method to invoke at run time. This is called late binding.

Because the C methodology always does late binding, a little more code must always be executed at run time. The C code may be a bit slower than the code generated by the C++ translator. However, when using virtual functions, I believe that the speed of sending a message in C is comparable to C++.

C++ inherits many of the characteristics of C. In C++, you have the ability to corrupt memory in the same ways that you can corrupt memory in C. This causes temporal and referential non-localization of bugs. C++ offers the same beneficial characteristics of C such as speed, compactness, and the possibility of portability.

• Microsoft C v5.1
• Microsoft Quick C v2.0
• Zortech C compiler

• Zortech C++ compiler
• Glockenspiel C++ translator using the Microsoft C compiler v5.1.

The utility module can use either the graphics library that accompanies Microsoft C v5.0 or the graphics library that comes with the Zortech C++ compiler.

If you are using the Microsoft graphics library and Hercules graphics, before you can run these programs you need to run MSHERC.COM.

The Zortech graphics library has its origin at the lower-left corner. Microsoft has its origin at the upper-left corner. Also, because pixels are not square, neither the Zortech nor the Microsoft libraries create perfectly round circles. Because this article is focusing on object-oriented techniques and not on graphical techniques, I didn't address any of these problems.

• Make a new class such as a diamond.
• Make a new method such as expand or contract that will change the size of an object.
• Adapt this system to another graphical system.