Instanced properties vs in class, C orienting objects with glib (GTK +)

C does not support inheritance or polymorphism natively because it is not object oriented ... however, there are mechanisms that allow you to simulate this behavior ... but you have to program them by hand.

Thus, a series of utilities must be implemented manually:

• Type inheritance: In C the concept of inheritance does not exist ... as much as it admits the composition.
• Polymorphism: Since there are no objects, C will not give you information about whether one type can be safely converted to another (as it does dynamic_cast in C ++)
• Virtual functions: You have to find a mechanism that allows you to work with virtual functions (a class can override the behavior of the parent class)
• Encapsulation: In C everything is public. There are no access modifiers so nothing prevents someone from modifying a member variable of your object.

Obviously it is not necessary to implement all these features ... but depending on the design you propose, it may be necessary to implement more than one.

How does GTK work?

C does not support many C ++ features, so if we want to emulate any of these features, we have to program it by hand.

In C ++:

• The class is a data type and determines the interface of the objects.
• The object is the variable that is created for a given class

That is:

class POO // <-- clase, es un tipo
{
public:
  int var; // <<-- interfaz de la clase
};

POO poo;      // <<-- poo es un objeto
poo.var = 10; // <<-- accedemos a las propiedades de poo,
              //      que vienen determinadas por su clase

However, in GTK they have chosen to isolate these two concepts for, among other reasons, isolation, reuse:

• isolation: Function pointers could be modified easily and inadvertently, which would corrupt the application. With this solution the function pointers are out of reach and it is GTK who manages them.
• reuse: All objects of the same class use the same function pointers, then it is not necessary to replicate those pointers in each created object ... with a single copy there is enough.

So, in GTK, you have a structure to manage the function pointers and another to manage the member variables:

// Objeto: Solo tiene las variables miembro
struct _WindowPrincipal
{
  GtkWindow *padre;

  GtkMenuBar *menuBar;
  GtkDrawingArea *areaDibujo;
  GtkGrid *grid;        
};

// Clase: Gestiona los punteros a función
struct _WindowPrincipalClass
{
    GtkWindowClass *clasePadre;

    GtkMenuBar (*menu) ();
    void (*design) (WindowPrincipal *self);
};

These two classes end up linking together in the GTK core with the subsequent configuration that needs to be done. Note that so far the only contact that these structures have had with GTK is limited to include GTK structures and pointers ... at no time have we told GTK that it should try a new type and even less how it should be treated. / p>

Your initial approach is good but you have not yet configured the GTK environment so you can work with your type.