Code:

class Mama {
  public:
    virtual void nesto() = 0;
    virtual void ime() { printf("Mama\n"); }
    Mama(int argGodina, int argDece = 1);
    virtual ~Mama();
  private:
    int _godina;
    int _kolikoDece;
};

class Dete {
  public:
    virtual void nesto();
    Dete(int argGodina, bool jedino = false);
    virtual ~Dete();
  private:
    bool _jedino;
};

Code:

typedef int (*VirtualFunctionPointer)();

struct VTable {
  int i;
  int d;
  VirtualFunctionPointer vtableFuncPtr;
};

struct Mama {
  int _godina;
  int _kolikoDece;
  // pokazivac na vtable
  VTable* vtablePtr;
};

struct Dete {
  // Nasledjeno od Mama tipa:
  int _godina;
  int _kolikoDece;
  // Clanovi dodani od strane "Dete" tipa:
  bool _jedino;
  // pokazivac na virtualnu funkciju
  VTable* vtablePtr;
};

Code:

VTable vtableMama[] = {
  // nesto() je cisti virtuelni metod, te se ne sme direktno zvati
  // zato pozovi pvc_error_handler() funkciju koja ce odmah da prijavi gresku.
  { 0, 0, pvc_error_handler },
  // ime() metod
  { 0, 0, Mama_ime },
  // ~Mama()
  { 0, 0, Mama_destructor}
};

VTable vtableDete[] = {
  // nesto() je virtuelni, ali konkretni, metod
  { 0, 0, Dete_nesto },
  // Poziva bazni ime() metod, jer u ovoj klasi nije definisan.
  { 0, 0, Mama_ime },
  // ~Dete()
  { 0, 0, Dete_destructor}
};

Code:

Mama* Mama_constructor(Mama* this, int argGodina, int argDece = 1)
{
  if (this == 0) {  // Ako memorija nije alocirana za strukturu Mama:
    this = malloc(sizeof(Mama));
  }
  if (this) { // mozda malloc() ipak nije uspeo...
    // inicijalizuj VTable pokazivac vtablePtr.
    this->vtablePtr = vtableMama;
    this->_godina = argGodina;
    this->_kolikoDece = argDece;
  }
  return this;
}

void Mama_destructor(Mama* this, bool dynamic)
{
  // Ponovo setujemo vtablePtr pointer, jer nije sigurno da on pokazuje na
  // "dobru" vrednost.

/****
  glavno telo destruktora
****/

  this->vtablePtr = vtableMama;
  // Oslobadjamo memoriju SAMO ako je memorija alocirana eksplicitno od strane Mama tipa
  if (dynamic) 
    free(this);
}

Dete* Dete_constructor(Dete* this, int argGodina, int argDece, int argJedino = 0)
{
  if (this == 0) {  // Ako memorija nije alocirana za strukturu Dete:
    this = malloc(sizeof(Dete));
  }
  if (this) { // mozda malloc() ipak nije uspeo...
    // Pozovi prvo konstruktor bazne klase
    Mama_constructor((Mama*)this, argGodina, argDece);
    // inicijalizuj VTable pokazivac vtablePtr.
    this->_jedino = argJedino;
  }
  return this;
}

void Dete_destructor(Dete* this, bool dynamic)
{
  // Ponovo inicijalizujemo vtablePtr pointer, jer nije sigurno da on pokazuje na
  // "dobru" vrednost.
  this->vtablePtr = vtableDete;

/****
  glavno telo destruktora
****/

  // Pozivamo destriktor baznog tipa - Mama
  Mama_destructor((Mama*) this, false);
  // Oslobadjamo memoriju SAMO ako je memorija alocirana eksplicitno od strane Dete tipa
  if (dynamic) 
    free(this);
}

Code:

/* ukratko, ipak je 2.11AM ... */

int main()
{
  // Kreiramo objekat tipa Dete, nema smisla kreirati objekat tipa Mama (apstraktna klasa).
  // S obzirom da je prvi argument (this) NULL onda ce se memorija alocirati...
  Mama* mamaPtr = Dete_constructor(NULL, 40, 2, true);
  Dete objekatDete;
  Dete_constructor(&objekatDete, 12, 0, 1);
  // Pozovimo virtuelni metod nesto()
  // Ovaj red je isto sto i: mamaPtr->nesto();
  (mamaPtr->vtablePtr[0].vtableFuncPtr)(mamaPtr);
  // Sledeci red je isto sto i mamaPtr->ime();
  (mamaPtr->vtablePtr[1].vtableFuncPtr)(mamaPtr);
  // Recimo da imamo metod imePrezime(str argIme, str argPrezime)
  // i da imamo negde dve promenljive str1 i str2 tipa str (#define std::string str recimo :)
  // I da je ova funkcija u VTables na mestu sa indeksom 5, onda bi je pozvali sa:
  (mamaPtr->vtablePtr[5].vtableFuncPtr)(mamaPtr, "Marina", "Perazic");
  // C++: delete objekatDete
  Dete_destructor(&objekatDete, false);
  return 0;
}