[maemo-developers] silly question

[From: Dodd, Robert]

Hello Carlos,

You can always write OO applications in C, but you do have to think about a little. I've pasted a simple example below. 

The example allows for method overriding, and method overloading(just!). Operator overloading is missing though. It's hacked out of some code for iPodLinux, not Maemo, but it will work anywhere you have a C compiler.

If you have a C++ compiler that's great, but you don't acually need it.

Regards,
Bob.

--- Object.h ----

#ifndef _Object
#define _Object 1

//////////////////////
// --- Constants ----
//////////////////////


///////////////////////////
// --- Object instance ---
///////////////////////////


typedef struct Object_objectInstance {

  int id;

  void (*destructor)(struct Object_objectInstance *thisPointer);
  void (*destructorAsSupertype)(struct Object_objectInstance *thisPointer);

} Object_objectInstance;


////////////////////////
// --- Constructors ---
////////////////////////

// used to create this class as a leaf class
Object_objectInstance* Object_constructor(void); 

// used to create this class as a supertype
Object_objectInstance* Object_constructorAsSupertype(Object_objectInstance* thisPointerStorage); 

//////////////////////////
// --- Static methods ---
//////////////////////////

#endif

--- Object.c ---


#include <stdlib.h>

#include "Object.h"


///////////////////////
// --- Static Data ---
///////////////////////

static int Object_uniqueId = 0;

//////////////////////
// --- Destructor ---
//////////////////////

void Object_destructorAsSupertype(Object_objectInstance* thisPointer ) {

} // Object_destructorAsSupertype()

void Object_destructor(Object_objectInstance* thisPointer ) {

  // pz_error("destructor must be overridden");

} // Object_destructor()


//////////////////////////
// --- Static Methods ---
//////////////////////////

///////////////////////////
// --- Dynamic Methods ---
///////////////////////////

////////////////////////
// --- Constructors ---
////////////////////////

Object_objectInstance* Object_constructorAsSupertype(Object_objectInstance* thisPointerStorage) {

  // Populate attributes
  thisPointerStorage -> id = Object_uniqueId++;

  // Populate method pointers
  thisPointerStorage -> destructor = &Object_destructor;
  thisPointerStorage -> destructorAsSupertype = &Object_destructorAsSupertype;

  return thisPointerStorage;

} // Object_constructorAsSupertype(thisPointerStorage)

Object_objectInstance* Object_constructor(void) {

  // pz_error("The constructor must be overridden");
 
} // Object_constructor()

--- Character.h ---

#ifndef _Character
#define _Character 1

#include "Object.h"

// Object instance
typedef struct Character_objectInstance {

  Object_objectInstance supertype;

  int value; // the value of the character as an integer (to allow for international 16 bit characters)

  void (*destructor)(struct Character_objectInstance *thisPointer);
  void (*destructorAsSupertype)(struct Character_objectInstance *thisPointer);

  void (*printChar)(struct Character_objectInstance* thisPointer);

} Character_objectInstance;


////////////////////////
// --- Constructors ---
////////////////////////

// used to create this class as a leaf
Character_objectInstance* Character_constructor(int value ); 

// used to create this class as a supertype
Character_objectInstance* M_Character_constructorAsSupertype(Character_objectInstance* thisPointer, int value); 

// static methods


#endif

--- Character.c ---


#include <stdlib.h>
#include <stdio.h>

#include "Object.h"
#include "Character.h"


///////////////////////
// --- Static Data ---
///////////////////////



//////////////////////
// --- Destructor ---
//////////////////////

void Character_destructorAsSupertype(Character_objectInstance* thisPointer ) {

  // Inform supertype
  thisPointer -> supertype.destructorAsSupertype((Object_objectInstance*) thisPointer);

} // Character_destructorAsSupertype()

void Character_destructor(Character_objectInstance* thisPointer ) {

  Character_destructorAsSupertype(thisPointer);
  free(thisPointer);

} // Character_destructor()

//////////////////////////
// --- Static Methods ---
//////////////////////////


///////////////////////////
// --- Dynamic Methods ---
///////////////////////////

void Character_printChar (Character_objectInstance* thisPointer) {

  printf("Char = %d\n", thisPointer -> value);

} // Character_printChar()


////////////////////////
// --- Constructors ---
////////////////////////


Character_objectInstance* Character_constructorAsSupertype(Character_objectInstance* thisPointerStorage, int value) {

  // construct supertype
  Object_constructorAsSupertype((Object_objectInstance*) thisPointerStorage);

  // populate attributes
  thisPointerStorage -> value = value;

  // Populate method pointers
  thisPointerStorage -> destructor = &Character_destructor;
  thisPointerStorage -> destructorAsSupertype = &Character_destructorAsSupertype;
  thisPointerStorage -> printChar = &Character_printChar;

  return thisPointerStorage;

} // Character_constructor(thisPointerStorage)

Character_objectInstance* Character_constructor(int value) {

  Character_objectInstance* thisPointer = malloc(sizeof(Character_objectInstance));
  return Character_constructorAsSupertype(thisPointer, value);
 
} // Character_constructor()

--- main.c ---

#include <stdio.h>

#include "Character.h"

int main( int argc, char** argv) {

  Character_objectInstance* ch = Character_constructor(0x30);
  ch -> printChar(ch);
  ch -> destructor(ch);

} // main()

-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://lists.maemo.org/pipermail/maemo-developers/attachments/20070528/66321588/attachment.htm