Orientación a objetos en C

Yo desaconsejaría el uso de preprocesador (ab) para intentar hacer que la sintaxis de C se parezca más a la de otro lenguaje más orientado a objetos. En el nivel más básico, simplemente usa estructuras simples como objetos y las pasa mediante punteros:

struct monkey
{
    float age;
    bool is_male;
    int happiness;
};

void monkey_dance(struct monkey *monkey)
{
    /* do a little dance */
}

Para conseguir cosas como la herencia y el polimorfismo, hay que trabajar un poco más. Puede hacer herencia manual haciendo que el primer miembro de una estructura sea una instancia de la superclase, y luego puede generar punteros a clases base y derivadas libremente:

struct base
{
    /* base class members */
};

struct derived
{
    struct base super;
    /* derived class members */
};

struct derived d;
struct base *base_ptr = (struct base *)&d;  // upcast
struct derived *derived_ptr = (struct derived *)base_ptr;  // downcast

Para obtener polimorfismo (es decir, funciones virtuales), se utilizan punteros de función y, opcionalmente, tablas de punteros de función, también conocidas como tablas virtuales o vtables:

struct base;
struct base_vtable
{
    void (*dance)(struct base *);
    void (*jump)(struct base *, int how_high);
};

struct base
{
    struct base_vtable *vtable;
    /* base members */
};

void base_dance(struct base *b)
{
    b->vtable->dance(b);
}

void base_jump(struct base *b, int how_high)
{
    b->vtable->jump(b, how_high);
}

struct derived1
{
    struct base super;
    /* derived1 members */
};

void derived1_dance(struct derived1 *d)
{
    /* implementation of derived1's dance function */
}

void derived1_jump(struct derived1 *d, int how_high)
{
    /* implementation of derived 1's jump function */
}

/* global vtable for derived1 */
struct base_vtable derived1_vtable =
{
    &derived1_dance, /* you might get a warning here about incompatible pointer types */
    &derived1_jump   /* you can ignore it, or perform a cast to get rid of it */
};

void derived1_init(struct derived1 *d)
{
    d->super.vtable = &derived1_vtable;
    /* init base members d->super.foo */
    /* init derived1 members d->foo */
}

struct derived2
{
    struct base super;
    /* derived2 members */
};

void derived2_dance(struct derived2 *d)
{
    /* implementation of derived2's dance function */
}

void derived2_jump(struct derived2 *d, int how_high)
{
    /* implementation of derived2's jump function */
}

struct base_vtable derived2_vtable =
{
   &derived2_dance,
   &derived2_jump
};

void derived2_init(struct derived2 *d)
{
    d->super.vtable = &derived2_vtable;
    /* init base members d->super.foo */
    /* init derived1 members d->foo */
}

int main(void)
{
    /* OK!  We're done with our declarations, now we can finally do some
       polymorphism in C */
    struct derived1 d1;
    derived1_init(&d1);

    struct derived2 d2;
    derived2_init(&d2);

    struct base *b1_ptr = (struct base *)&d1;
    struct base *b2_ptr = (struct base *)&d2;

    base_dance(b1_ptr);  /* calls derived1_dance */
    base_dance(b2_ptr);  /* calls derived2_dance */

    base_jump(b1_ptr, 42);  /* calls derived1_jump */
    base_jump(b2_ptr, 42);  /* calls derived2_jump */

    return 0;
}

Y así es como se hace el polimorfismo en C. No es bonito, pero cumple su función. Hay algunos problemas complicados relacionados con la conversión de punteros entre las clases base y derivadas, que son seguras siempre que la clase base sea el primer miembro de la clase derivada. La herencia múltiple es mucho más difícil; en ese caso, para diferenciar entre clases base distintas de la primera, debe ajustar manualmente los punteros en función de las compensaciones adecuadas, lo cual es realmente complicado y propenso a errores.

¡Otra cosa (complicada) que puedes hacer es cambiar el tipo dinámico de un objeto en tiempo de ejecución! Simplemente reasigne un nuevo puntero vtable. Incluso puedes cambiar selectivamente algunas de las funciones virtuales y mantener otras, creando nuevos tipos híbridos. Solo tenga cuidado de crear una nueva vtable en lugar de modificar la vtable global; de lo contrario, afectará accidentalmente a todos los objetos de un tipo determinado.

Jan 06 '2009 05:01 Adam Rosenfield