Object Oriented C Reboot

As is normally the case I started something and then put it down and did lots of other things instead. In a rare bout of refocusing though I'm picking up the object oriented C (OCode) stuff again.

Previously I got very side tracked into setting up a perfect development environment as I would like to use at work. Something that would be compatible with automated build systems. Furthermore, I started trying to port the subversion externals pattern that I like to use for shared code to Git on GitHub - I quickly discovered that I'm still very much a Git newbie. This was not very lean of me...

So i'm rebooting. This time around I will focus on the task at hand which is to create a simple templating and/or preprocessing system for generating class and interface boiler plate for use in OpenTV applications which are exclusively written in C.

Let's start with a description of the pattern I currently use to implement classes. This part is simple and the boiler plate is not so bad.

The header:

	#ifndef MyClass_H
	#define MyClass_H
	typedef struct _MyClass MyClass;
	extern MyClass * MyClass_create(int nMyField);
	extern void MyClass_destroy(MyClass * pThis);
	extern int MyClass_getMyField(MyClass * pThis);
	#endif

view raw MyClass.h hosted with ❤ by GitHub

The implementation:

	#include "MyClass.h"
	#include "opentv.h"
	struct _MyClass
	{
	int nMyField;
	};
	MyClass * MyClass_create(int nMyField)
	{
	MyClass * pThis = O_malloc(sizeof(MyClass));
	pThis->nMyField = nMyField;
	return pThis;
	}
	void MyClass_destroy(MyClass * pThis)
	{
	O_free(pThis);
	}
	int MyClass_getMyField(MyClass * pThis)
	{
	return pThis->myField;
	}

view raw MyClass.c hosted with ❤ by GitHub

Excuse any obvious errors, I just typed that out without trying to run or compile it, but i think you can get the idea - nicely encapsulated, right?

So that's all good. A little boiler plate in exposing opaque types and constructors/destructors but not so bad. The problems/challenges(/opportunities ;)) start when I try to extend this pattern with interfaces. Let's extend the example with that pattern.

The interface:

	#ifndef MyInterface_H
	#define MyInterface_H
	#include "opentv.h"
	/*
	Prototype a method signature to be implemented for
	this interface. Allows the compiler to spot errors
	but can't get round the void pointer for the instance
	*/
	typedef int (* MyInterface_MyMethod)(void * pInstance, int nArgument);
	/* Interface structure (vtable?) */
	typedef struct
	{
	void * pInstance;
	MyInterface_MyMethod cbMyMethod;
	}
	MyInterface;
	/*
	Interface constructor. I use static inline for all
	interface methods so that they compile out much like
	preprocessor stuff but also the compiler will help me
	with type checking, etc
	*/
	static inline MyInterface * MyInterface_create(void * pInstance, MyInterface_MyMethod cbMyMethod)
	{
	MyInterface * pThis = O_malloc(sizeof(MyInterface));
	pThis->pInstance = pInstance;
	pThis->cbMyMethod = cbMyMethod;
	return pThis;
	}
	/* Interface destructor */
	static inline void MyInterface_destroy(MyInterface * pThis)
	{
	O_free(pThis);
	}
	/*
	This method allows the implementation of MyInterface_MyMethod
	to be called thus facilitating polymorphism which is our end goal
	*/
	static inline int MyInterface_myMethod(MyInterface * pThis, int nArgument)
	{
	return pThis->cbMyMethod(pThis->pInstance, nArgument);
	}
	#endif

view raw MyInterface.h hosted with ❤ by GitHub

Now we can see some really obvious complexity. Just look at the length of it and it doesn't even do anything really. Immediately apparent is how much work it would be to add a new method to the interface.

1. Add a new typedef for the method prototype
2. Add a field to the interface structure
3. Add an argument to the interface constructor
4. Add a redirector method to allow the implementation to be called

It's fiddly work and potentially error prone (and this stuff can be hard to debug). The good news is that interfaces tend to be fairly stable once done as they don't contain business logic (although they may represent it I guess).

We're not finished though. The interface has to be implemented by our class for it to be useful.

Here's the new header for our class:

	#ifndef MyClass_H
	#define MyClass_H
	/* Need to include the interface header */
	#include "MyInterface.h"
	typedef struct _MyClass MyClass;
	extern MyClass * MyClass_create(int nMyField);
	extern void MyClass_destroy(MyClass * pThis);
	extern int MyClass_getMyField(MyClass * pThis);
	/* New method to "cast" MyClass to MyInterface */
	extern MyInterface * MyClass_asMyInterface(MyClass * pThis);
	#endif

view raw MyClassWithMyInterface.h hosted with ❤ by GitHub

Notice the addition of a method to get an instance as an instance of MyInterface this is our casting convention.

Here's the new implementation of our class:

	#include "MyClass.h"
	#include "opentv.h"
	struct _MyClass
	{
	/* Need a field to store the interface instance */
	MyInterface * pMyInterface;
	int nMyField;
	};
	/*
	private implementation of a MyInterface_MyMethod method - we keep
	the void pointer parameter so that we don't have to cast the method
	when passing it into the interface constructor. Doing so could hide nasty
	type errors further down the road.
	*/
	static int MyClass_myMethod(void * pInstance, int nArgument)
	{
	/*
	this #define is an optimisation that I use instead
	of adding a local variable to the stack. It's pretty
	optional but I worry about this sort of thing when
	running code on low horsepower set top boxes
	*/
	#define pThis ((MyClass *) pInstance)
	/* ooh, look - that's what myMethod is for ;) */
	return pThis->nMyField + nArgument;
	/*
	let's not forget to undef pThis we may want to use
	that name a lot in other methods ;)
	*/
	#undef pThis
	}
	MyClass * MyClass_create(int nMyField)
	{
	MyClass * pThis = O_malloc(sizeof(MyClass));
	/* Construct an interface instance */
	pThis->pMyInterface = MyInterface_create(pThis, MyClass_myMethod);
	pThis->nMyField = nMyField;
	return pThis;
	}
	void MyClass_destroy(MyClass * pThis)
	{
	/* don't forget to destroy the interface instance */
	MyInterface_destroy(pThis->pMyInterface);
	O_free(pThis);
	}
	int MyClass_getMyField(MyClass * pThis)
	{
	return pThis->nMyField;
	}
	/* Casting convention implementation */
	MyInterface * MyClass_asMyInterface(MyClass * pThis)
	{
	return pThis->pMyInterface;
	}

view raw MyClassWithMyInterface.c hosted with ❤ by GitHub

That wasn't so bad, we:

1. Added a field to the class structure to store the interface instance
2. Implemented the interface method
3. Constructed an interface instance in the class constructor
4. Destroyed the interface instance in the class destructor
5. Added the method to implement our casting convention

Again it was fiddly though and remembering that we have to do these things in every class that implements the interface we are now exposed to following types of errors:

• Memory leaks due to forgetting to destroy the interface
• Strange affects from casting incorrectly in method implementations (doesn't seem likely until you remember that casts are a nightmare for hiding copy paste errors)

So let's review. We now have 3 quite complicated files that are quite hard to maintain. Particularly, changes in interfaces result in a large quantity of refactoring radiating out all over the place. Plus we have to be careful whenever we implement a new instance of an interface. And remember that this example only implements 1 interface method!

This is a barrier to using the pattern which I would like to overcome. Just writing it up took longer than I expected and I have to go out now so I guess there will be a part 2 where I actually get started on how I would like it to look and work :)

...
...
...

As an aside the work I have been doing to make OpenTV application generating and testing makefiles using make function implementations will likely be the subject of a future post. As will figuring out how to share code and resources across Git repositories/projects.