Saltar al contenido

¿Cómo se implementa una clase en C?

septiembre 22, 2021
apple touch icon@2

Eso depende del conjunto de características exacto «orientado a objetos» que desee tener. Si necesita cosas como sobrecarga y / o métodos virtuales, probablemente necesite incluir punteros de función en las estructuras:

typedef struct {
  float (*computeArea)(const ShapeClass *shape);
} ShapeClass;

float shape_computeArea(const ShapeClass *shape)
{
  return shape->computeArea(shape);
}

Esto le permitiría implementar una clase, «heredando» la clase base e implementando una función adecuada:

typedef struct {
  ShapeClass shape;
  float width, height;
} RectangleClass;

static float rectangle_computeArea(const ShapeClass *shape)
{
  const RectangleClass *rect = (const RectangleClass *) shape;
  return rect->width * rect->height;
}

Esto, por supuesto, requiere que también implemente un constructor, que se asegura de que el puntero de función esté configurado correctamente. Normalmente, asignaría dinámicamente memoria para la instancia, pero también puede dejar que la persona que llama lo haga:

void rectangle_new(RectangleClass *rect)
{
  rect->width = rect->height = 0.f;
  rect->shape.computeArea = rectangle_computeArea;
}

Si quieres varios constructores diferentes, tendrás que «decorar» los nombres de las funciones, no puedes tener más de uno. rectangle_new() función:

void rectangle_new_with_lengths(RectangleClass *rect, float width, float height)
{
  rectangle_new(rect);
  rect->width = width;
  rect->height = height;
}

Aquí hay un ejemplo básico que muestra el uso:

int main(void)
{
  RectangleClass r1;

  rectangle_new_with_lengths(&r1, 4.f, 5.f);
  printf("rectangle r1's area is %f units squaren", shape_computeArea(&r1));
  return 0;
}

Espero que esto les dé algunas ideas, al menos. Para un marco orientado a objetos exitoso y rico en C, busque en glib’s GObject Biblioteca.

También tenga en cuenta que no hay una «clase» explícita que se modela arriba, cada objeto tiene sus propios punteros de método que es un poco más flexible de lo que normalmente encontraría en C ++. Además, cuesta memoria. Podrías alejarte de eso rellenando los punteros del método en un class estructura e inventar una forma para que cada instancia de objeto haga referencia a una clase.

close