Comment gérer le type de pointeur incompatible lors de l'affectation de méthodes virtuelles dans une classe dérivée?

Question

J'ai les classes GLib Foo et DerivedFoo.

La classe Foo a une méthode bar():

typedef struct _FooClass 
{ 
    GObjectClass parent_class; 

    void (*bar) (Foo *self); 
} FooClass; 

La classe DerivedFoo dérive de Foo et met en œuvre la méthode bar():

void derived_foo_bar (DerivedFoo *self); 

static void 
derived_foo_class_init (DerivedFooClass *klass) 
{ 
    FooClass *foo_class = FOO_CLASS (klass); 
    // Compiler warning appears here 
    foo_class->bar = derived_foo_bar; 
} 

Le message d'avertissement est:

warning: assignment from incompatible pointer type 

Les pointeurs ne sont pas compatibles, car le type du paramètre self est différent (Foo * par rapport à DerivedFoo *).

Est-ce la bonne façon d'implémenter des méthodes virtuelles dans GObject?

Si oui, peut/devrais-je faire quelque chose à propos de l'avertissement du compilateur?

Answer 1

Vous quittez le prototype de fonction pour respecter la classe de base virtuelle et le transposez dans votre fonction à l'aide de macros/fonctions glib.

void derived_foo_bar (Foo *self); 

static void 
derived_foo_class_init (DerivedFooClass *klass) 
{ 
    FooClass *foo_class = FOO_CLASS (klass); 
    // Compiler warning appears here 
    foo_class->bar = derived_foo_bar; 
} 

void derived_foo_bar (Foo *_self) 
{ 
    DerivedFoo *self = DERIVED_FOO (self); /* or whatever you have named this macro, using the standard GLIB semantics */ 
/* If self is not compatible with DerivedFoo, a warning will be issued from glib typecasting logic */ 
}