( utpKabel | 2014. 04. 26., szo – 17:08 )

Kemeny ...

Megirod 0-rol es maintaineled.

Ez az egész kb. olyan szintű probléma, mint headerfájlokban a függvényfejlécek megismétlése... a maintenance is...
Ha valaki a C-t vagy C++-t eddig el tudta viselni, akkor ez már ne tartsa vissza...

C++

class IFoo {
public:
  virtual int spam() = 0;
  virtual void egg(int) = 0;
};

class Foo : public IFoo {
public:
  Foo();
  virtual int spam();
  virtual void egg(int);
private:
  // ide jönnek az adattagok
};

Foo::Foo()
{
  // tagok inicializálása
}

int Foo::spam()
{
  // implementáció
}

void Foo::egg(int value)
{
  // implementáció
}

C

struct _IFoo_VTable {
  int (*spam)(void *self_);
  void (*egg)(void *self_, int);
};

typedef struct _IFoo {
  const struct _IFoo_VTable *vtab;
} *IFoo;

struct Foo {
  struct _IFoo _;
  // ide jönnek az adattagok
};

int Foo_spam(void *self_)
{
  struct Foo self = self_;
  // implementáció
}

void Foo_egg(void *self_, int value)
{
  struct Foo self = self_;
  // implementáció
}

static const struct _IFoo_VTable Foo_vtab = {
  Foo_spam,
  Foo_egg
};

struct Foo *newFoo(struct Foo *self)
{
  if (self == NULL)
    self = malloc(sizeof(*self));
  self->_.vtab = &Foo_vtab;
  // tagok inicializálása
  return self;
}

#define spam(obj) ((obj)->vtab->spam((obj)))
#define egg(obj,value) ((obj)->vtab->spam((obj), (value)))

Igen, a C-s változat kicsit hosszabb, de ez érthető, hiszen a C++-t eredetileg pont ez a pár sor megspórolása végett találták ki.