GObject调用父类函数

最近在分析Gstreamer的代码时，发现GstPipeline中有如下代码：

result = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);

但搜索当前文件并没有发现有对parent_class变量的定义，查询后发现这是GObject在相应宏展开时所定义的一个静态变量，当使用G_DEFINE_TYPE宏定义一个GObject对象时，宏会自动展开生成相应的代码，子类可以通过parent_class调用父类的函数。下面对这种使用方式做一个简单分析。

强制转换

在GObject的介绍中提到，父类的结构体必须作为子类结构体的第一个成员，由于C语言中定义第一个结构体数据必须存放在所分配内存的起始位，所以这样可以通过快速强制转换访问父类成员，这也是C语言里的一个重要的技巧，示例如下：

 struct _GTypeClass{
   GType g_type;
 };
 struct _GTypeInstance{
   GTypeClass *g_class;
 };
 /* A definitions */
 typedef struct {
   GTypeInstance parent;
   int field_a;
   int field_b;
 } A;
 typedef struct {
   GTypeClass parent_class;
   void (*method_a) (void);
   void (*method_b) (void);
 } AClass;

 /* B definitions. */
 typedef struct {
   A parent;
   int field_c;
   int field_d;
 } B;
 typedef struct {
   AClass parent_class;
   void (*method_c) (void);
   void (*method_d) (void);
 } BClass;

 B *b;
 b->parent.parent.g_class->g_type //普通顺序访问
 ((GTypeInstance *) b)->g_class->g_type //快速强制转换

同样在GstPipeline的声明中，父类同样是作为子类的第一个结构体成员：

 #define GST_TYPE_PIPELINE               (gst_pipeline_get_type ())

 struct _GstPipeline {
   GstBin         bin;
   ...
 };

 struct _GstPipelineClass {
   GstBinClass parent_class;
   ...
 };

G_DEFINE_TYPE宏

为了能让GObject在new出一个对象的时候顺利找到相应类型，必须将自定义的类添加到类型系统里面，GObject提供了一系列的 G_DEFINE_TYPE 宏来快速定义一个新的对象类型，GstPipeline则通过下列宏定义对象：

 G_DEFINE_TYPE_WITH_CODE (GstPipeline, gst_pipeline, GST_TYPE_BIN, _do_init);

我们可以通过GCC的预处理来展开宏，查看生成的代码:

 $ cd gstreamer-1.14.
 $ gcc -E `pkg-config --cflags glib-2.0` -I. gst/gstpipeline.c > gstpipeline_preposs.c
 $ clang-format -i gstpipeline_preposs.c  

宏展开后，主要生成一个父类class对象的指针（parent_class），class对象的内部初始化接口（gst_pipeline_class_intern_init）获取唯一标识当前类型的接口（gst_pipeline_get_type），parent_class也会在class init的时候进行初始化：

 static void gst_pipeline_init(GstPipeline *self);
 static void gst_pipeline_class_init(GstPipelineClass *klass);
 static gpointer parent_class = ((void *)) ;

 // init parent_class pointer to GstBinClass
 // and call user defined class init function.
 static void gst_pipeline_class_intern_init(gpointer klass) {
   parent_class = g_type_class_peek_parent(klass);
   gst_pipeline_class_init((GstPipelineClass *)klass);
 }

 // generate unique id for each class
 // and register instance and class init functions
 GType gst_pipeline_get_type(void) {
   static volatile gsize g_define_type_id__volatile = ;
   if ( g_once_init_enter(&g_define_type_id__volatile)) {
     GType g_define_type_id = g_type_register_static_simple(
       (gst_bin_get_type()),                   /* GST_TYPE_BIN  parent type*/
       g_intern_static_string("GstPipeline"),  /* type name */
       sizeof(GstPipelineClass),               /* class size */
       (GClassInitFunc)gst_pipeline_class_intern_init, /* class init */
       sizeof(GstPipeline),                            /* instance size */
       (GInstanceInitFunc)gst_pipeline_init,           /* instance init */
       (GTypeFlags));                                 /* flags */
      ...
       g_once_init_leave((&g_define_type_id__volatile), (gsize)(g_define_type_id));
     }
     return g_define_type_id__volatile;
 }

创建GObject对象

创建GObject对象需要通过g_object_new()，这个接口的第一个函数就是需要创建对象的类型，比如我们可以通过如下方式创建GstPipeline对象：

 GstPipeline *pipeline = g_object_new (GST_TYPE_PIPELINE, "name", "pipeline1", NULL);

这里的GST_TYPE_PIPELINE是GstPipeline的类型，这个宏被定义为gst_pipeline_get_type()，这个函数通过上面提到的宏展开得到。

当对象被创建时，我们定义的类对象（GstPipelineClass）初始化函数gst_pipeline_class_init() 被调用，然后对象实例（GstPipeline）初始化函数被调用 gst_pipeline_init()。

这里之所以需要持有父类class对象的指针，是因为当子类在执行class init时，可以覆盖父类的方法，如果将子类class对象强制转换为父类class对象，调用的方法任然是子类重写了的方法，所以这里必须持有父类class对象的指针（parent_class），才可以调用父类的方法。

在子类中调用父类函数

在子类中调用父类方法，我们只需将parent_class转换为父类class对象，通过函数指针调用即可。例如GstPipeline中获取时钟的方法：

 GST_ELEMENT_CLASS (parent_class)->provide_clock (GST_ELEMENT(pipeline));

由于GstPipeline的父类是GstBin，GstBin的父类是GstElement，在GstBin的class init函数gst_bin_class_init中，provide_clock被初始化为 gst_bin_provide_clock_func，在子类GstPipeline的class init函数gst_pipeline_class_init中，provide_clock被初始化为gst_pipeline_provide_clock_func。

因此在GstPipeline中就可以通过parent_class调用GstBin中的接口。

这套机制只能保证子类可以调用父类的方法，可能能显示调用父类以上基类的接口，例如上例中，如果GstElement中也有一个provide_clock的实现，则在GstPipeline中无法直接调用GstElement中的实现。

遗留问题

在G_DEFINE_TYPE宏的实现中，parent_class还带有一个前缀，如下：

 #define _G_DEFINE_TYPE_EXTENDED_BEGIN_PRE(TypeName, type_name, TYPE_PARENT) \
 ...\
 static gpointer type_name##_parent_class = NULL; \
 ...

但实际展开的代码为：

 static gpointer parent_class = ((void *)) ;

为什么这里会去掉type_name还不得而知。

20190517更新：

因为在G_DEFINE_TYPE前，将gst_pipeline_parent_class定义为一个宏，所以G_DEFINE_TYPE展开后，及为parent_class.

 #define gst_pipeline_parent_class parent_class
 G_DEFINE_TYPE_WITH_CODE (GstStream, gst_stream, GST_TYPE_OBJECT, _do_init);

引用

https://github.com/GNOME/glib/blob/master/gobject/gtype.h
https://developer.gnome.org/gobject/stable/gobject-Type-Information.htm
https://developer.gnome.org/gobject/stable/gobject-The-Base-Object-Type.html
https://developer.gnome.org/gobject/stable/gtype-instantiable-classed.html

作者：John.Leng

出处：http://www.cnblogs.com/xleng/

本文版权归作者所有，欢迎转载。商业转载请联系作者获得授权，非商业转载请在文章页面明显位置给出原文连接.