Simulating Classes in C - Part 2

Well the $1 C contest has come to an end after generating lots of interest but no full blown solutions. I'm okay with that, thanks to all of you who expressed interest and started on it. From conversations with several of you over chat, I know that there were some great ideas out there. If you don't mind taking the time, please describe your idea in the comments section. As my friend Matt can attest, I love discussing software, ideas, designs, and just about anything related to creative problem solving. This is probably why I really enjoyed math in high school and college. I looked at each problem as a logic puzzle which could be solved multiple ways. Finding the most elegant solution made me feel like I had just written a poem of supreme beauty.

/* JSObject functions */
void InvokeObjectMethod(JSObject* object, char* methodName,
                       JSListOfObjects* inputParams,
                       JSListOfObjects* outputParams) {
 int i;
 JSClass* class_of_object;
 int method_index = -1;

 /* Impossible to invoke a method on a NULL pointer  */
 if(object == NULL) {
   /* ToDo: send a "NULL object" error code in the outputParams. */
   return;
 }

 class_of_object = (JSClass*)(object->type);

 if(class_of_object == NULL) {
   /* ToDo: send a "NULL class" error code in the outputParams. */
   return;
 }

 /* Find the index of the methodName in the object's class.  */
 /* This part of the code is O(n) efficient, but this could be
    improved if the function names were sorted or if a hash
    algorithm was used. Hashing could reduce to O(1). */
 /* I could also allow the calling code to specify the desired
    method directly by index to avoid requiring a string
    lookup for each invocation. */
 for(i = 0; i <>method_count; i++) {
   if(strcmp(class_of_object->method_names[i], methodName) == 0) {
     method_index = i;
     break;
   }
 }

 /* If the method name was not found in the list of class methods,
    return an error code. */
 if(method_index == -1) {
   /* ToDo: send a "method not found" error code in the
      outputParams. */
   return;
 }

 /* Invoke the method at the index corresponding to the method
    name. */
 (*(class_of_object->methods[method_index]))(object, inputParams,
                                             outputParams);
}

I wrote my solution a few weeks ago, then started researching how other object oriented schemes are implemented. I found out that my code has several disadvantages and some significant advantages as well. For example, I started to comapre the likelyhood of missing the RAM cache to solutions in C++ and Java. There were a few other intersting comparisons but I won't go into all of the nitty gritty details. Overall, I'm very pleased because I learned a lot. Lets discuss!

Simulating classes in C

I have to admit, I like to program in C. In some ways, it is simpler than some of the newer, high level languages, and I really enjoy being closer to the machine code. Perhaps I'm a bit obsessive about efficiency. Still, I sometimes long for classes and objects in my C programs, (This is where you tell me that I should use C++ or Objective-C.) so I decided to figure out how I could simulate classes in plain old ANSI C.

It turned out to be quite easy. After I read up on function pointers, I created a struct which contains references to functions (kind of like class methods). Here's a simple example of what I'm talking about:

#include<stdio.h>

typedef struct {
  int (*test)(int); /* This is the function pointer */
} functionholder;

/* At runtime, I will point to this function */
int thefunction(int x) {
  printf("thefunction says %i\n", x);
  return 0;
}

int main() {
  functionholder fholder;
  fholder.test = &thefunction;
  (*fholder.test)(7);
  return 0;
}

When I run the above, the program prints "thefunction says 7".
From there, I decided to create a family of structures which would simulate classes, objects, and allow polymorphic function calls.

One way to divide up data and methods in an OO way is to say that the class dictates the methods which can be used with the data in an object instance. So we could say that a class contains a list of functions. Using function pointers, the method called can be changed at runtime, as long as all of the functions have the same stack profile. Have I lost you yet? So what I needed to do was create a generic function prototype which abstracts the parameter list into a common format. While I was at it, I decided to lose the restriction that methods return only one value, so the results of a method call will be stored in a structure which is passed in as a parameter. (The method should probably be called a procedure instead of a function.) Perhaps it would be simpler to show you the code.

typedef struct {
  void* type; /* This will point to a JSClass. */
  void* data;
} JSObject;

typedef struct {
  int object_count; /* number of objects in the array */
  JSObject** objects; /* An array of pointers to JSObjects */
} JSListOfObjects;

typedef struct {
  char* name;
  /* Each JSClass contains a list of pointers to the methods which belong
   * to that class. */
  int method_count;
  /* strings naming the functions (allow method lookup by string) */
  char **method_names;
  /* An array of pointers to functions */
  void (**methods)(JSObject* x, JSListOfObjects* y, JSListOfObjects* z);
} JSClass;

I was going to discuss the functions I created to streamline "class" method invocation, but this post is getting a bit long. So I've decided to try something fun. I'm going to ask you, gentle reader, to suggest a design for a function which simplifies invocation of an object method. I will mail $1 (USD) to the person who posts the "best" working solution in the comments below. (I'll be compiling using gcc -ansi. Oh, and US residents only, I don't want to run into any strange rules.). In addition to a dollar, you'll have won bragging rights for the first of my blog challenges. After a week or two, I'll post my solution and we can all compare notes. Happy coding!