glib实践篇：父类与子类

前言：

　　众所周知，C语言是一门面向过程的语言，但是不代表就得跟面向对象完全绝缘，在C语言库glib中有gobject那么一套面向对象的机制，基于C语言的面向对象设计便是基于该实现机制。

　　今天所要实践的便是面向对象的一个重要特征：抽象与继承

　　笔者的水平有限，如果文章有什么错误的地方还望指出。

1、设计说明

　　开发语言：C语言

　　基础库：glib

　　设计目的：简要设计类来实现抽象与继承

2、由几个有相同属性或操作的类抽象出一个父类。

　　这里简单使用gobject的一套设计模板，细节部分不做说明，有研究兴趣的读者可以研究一下。

　　父类：base（该类由base.h和base.c共同组成）

　　base.h

 #ifndef __BASE_H__
 #define __BASE_H__
 
 #include <glib.h>
 #include <stdio.h>
 #include <glib-object.h>
 G_BEGIN_DECLS
 
 #define BASE_TYPE                    (base_get_type ())//该对象的类型
 #define BASE(o)                       (G_TYPE_CHECK_INSTANCE_CAST ((o), BASE_TYPE, Base))//类型转换，转换为该对象的类型
 #define BASE_CLASS(k)                 (G_TYPE_CHECK_CLASS_CAST((k), BASE_TYPE, BaseClass))
 #define IS_BASE(o)                    (G_TYPE_CHECK_INSTANCE_TYPE ((o), BASE_TYPE))
 #define IS_BASE_CLASS(k)              (G_TYPE_CHECK_CLASS_TYPE ((k), BASE_TYPE))
 #define BASE_GET_CLASS(o)             (G_TYPE_INSTANCE_GET_CLASS ((o), BASE_TYPE, BaseClass))
 #define BASE_CAST(obj)              ((Base*)(obj))
 
 typedef struct _Base        Base;
 typedef struct _BaseClass   BaseClass;
 typedef struct _BasePrivate BasePrivate;
 
 struct _Base
 {
     GObject    parent;
     //设置共有变量，提供给子类访问
     GString *str;
 };
 
 struct _BaseClass
 {
     GObjectClass    parentclass;
     //设置设置写和读名字的方法，由子类重载
     void (*showKill)(Base *self);
     char *(*getSkill)(Base *self);
 };
 
 GType                 base_get_type  (void);
 //这些方法被子类所共有，其中skill的操作方法需要由子类重载。
 void               base_set_name(Base *self,char *name);
 char *            base_get_name(Base *self);
 void                 base_show_skill(Base *self);
 char *            base_get_skill(Base *self);
 
 G_END_DECLS
 
 #endif /* ABSTRACTMODEL_H_ */

basec.c

 #include "base.h"
 #include <string.h>
 
 //父类即抽象类的宏定义，继承自object
 G_DEFINE_ABSTRACT_TYPE(Base, base, G_TYPE_OBJECT);
 
 #define GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), BASE_TYPE, Base))
 
 struct _BasePrivate
 {
     char *name;
 };
 
 static void dispose_od(GObject *object);
 static void finalize_od(GObject *object);
 
 static void base_class_init(BaseClass *klass)
 {
     GObjectClass *object_class = G_OBJECT_CLASS(klass);
     g_type_class_add_private(klass, sizeof(BasePrivate));
     object_class->dispose = dispose_od;
     object_class->finalize = finalize_od;
 }
 
 static void base_init(Base *self)
 {
     BasePrivate *priv = GET_PRIVATE(self);
     self->str = g_string_new("暴露出来给你们访问的");
 }
 static void dispose_od(GObject *object)
 {
     Base *self = BASE(object);
     BasePrivate *priv = GET_PRIVATE(self);
     if(self->str)
     {
         g_string_free(self->str,TRUE);
         self->str=NULL;
     }
     G_OBJECT_CLASS(base_parent_class)->dispose(object);
 }
 
 static void finalize_od(GObject *object)
 {
     Base *self = BASE(object);
     BasePrivate *priv = GET_PRIVATE(self);
 
     G_OBJECT_CLASS(base_parent_class)->finalize(object);
 }
 
 void    base_set_name(Base *self,char *name)
 {
     BasePrivate *priv = GET_PRIVATE(self);
     priv->name = strdup(name);
 }
 char *base_get_name(Base *self)
 {
     BasePrivate *priv = GET_PRIVATE(self);
     return priv->name;
 }
 
 void base_show_skill(Base *self)
 {
     if (self)
     {
         BaseClass *baseClass = BASE_GET_CLASS(self);
         baseClass->showKill(self);
     }
 }
 char * base_get_skill(Base *self)
 {
     char *skill = NULL;
     if (self)
     {
         BaseClass *baseClass = BASE_GET_CLASS(self);
         skill = baseClass->getSkill(self);
     }
     return skill;
 }

　　子类1：(由文件subbase1.h和subbase.c组成)

　　subbase1.h

 #ifndef __SUBBASE1_H__
 #define __SUBBASE1_H__
 
 #include <glib.h>
 #include <stdio.h>
 #include <glib-object.h>
 #include"base.h"
 G_BEGIN_DECLS
 
 #define SUBBASE1_TYPE                    (subbase1_get_type ())//该对象的类型
 #define SUBBASE1(o)                       (G_TYPE_CHECK_INSTANCE_CAST ((o), SUBBASE1_TYPE, Subbase1))//类型转换，转换为该对象的类型
 #define SUBBASE1_CLASS(k)                 (G_TYPE_CHECK_CLASS_CAST((k), SUBBASE1_TYPE, Subbase1Class))
 #define IS_SUBBASE1(o)                    (G_TYPE_CHECK_INSTANCE_TYPE ((o), SUBBASE1_TYPE))
 #define IS_SUBBASE1_CLASS(k)              (G_TYPE_CHECK_CLASS_TYPE ((k), SUBBASE1_TYPE))
 #define SUBBASE1_GET_CLASS(o)             (G_TYPE_INSTANCE_GET_CLASS ((o), SUBBASE1_TYPE, Subbase1Class))
 #define SUBBASE1_CAST(obj)              ((Subbase1*)(obj))
 
 typedef struct _Subbase1        Subbase1;
 typedef struct _Subbase1Class   Subbase1Class;
 typedef struct _Subbase1Private Subbase1Private;
 
 struct _Subbase1
 {
     Base    parent;
 };
 
 struct _Subbase1Class
 {
     BaseClass    parentclass;
 };
 
 GType                 subbase1_get_type  (void);
 Subbase1*                     subbase1_new(void);
 void                    subbase1_sing_song(Subbase1    *self,char *song);
 
 G_END_DECLS
 #endif /* ABSTRACTMODEL_H_ */

　　subbase1.c

 #include "subbase1.h"
 #include <string.h>
 
 //子类的宏定义，继承父类类型
 G_DEFINE_TYPE(Subbase1, subbase1, BASE_TYPE);
 
 #define GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SUBBASE1_TYPE, Subbase1))
 
 struct _Subbase1Private
 {
 };
 
 static void dispose_od(GObject *object);
 static void finalize_od(GObject *object);
 static char *getSkill_od(Base *self);
 static void    showKill_od(Base *self);
 static void subbase1_class_init(Subbase1Class *klass)
 {
     GObjectClass *object_class = G_OBJECT_CLASS(klass);
     g_type_class_add_private(klass, sizeof(Subbase1Private));
     object_class->dispose = dispose_od;
     object_class->finalize = finalize_od;
     BaseClass *baseClass = BASE_CLASS(klass);
     baseClass->getSkill =getSkill_od;
     baseClass->showKill = showKill_od;
 
 }
 
 static void subbase1_init(Subbase1 *self)
 {
     Subbase1Private *priv = GET_PRIVATE(self);
 }
 static void dispose_od(GObject *object)
 {
     Subbase1 *self = SUBBASE1(object);
     Subbase1Private *priv = GET_PRIVATE(self);
 
     G_OBJECT_CLASS(subbase1_parent_class)->dispose(object);
 }
 
 static void finalize_od(GObject *object)
 {
     Subbase1 *self = SUBBASE1(object);
     Subbase1Private *priv = GET_PRIVATE(self);
 
     G_OBJECT_CLASS(subbase1_parent_class)->finalize(object);
 }
 static char *getSkill_od(Base *self)
 {
     return "sing";
 }
 static void    showKill_od(Base *self)
 {
     g_print("I singing!\n");
 }
 
 Subbase1*         subbase1_new(void)
 {
     Subbase1 *res = g_object_new(SUBBASE1_TYPE,NULL);
     return res;
 
 }
 void    subbase1_sing_song(Subbase1    *self,char *song)
 {
     g_print("I singing a song for name is %s!\n",song);
 }

　　子类2：(由subbase2.h和subbase2.c文件组成)

　　subbase2.h

 #ifndef __SUBBASE2_H__
 #define __SUBBASE2_H__
 
 #include <glib.h>
 #include <stdio.h>
 #include <glib-object.h>
 #include"base.h"
 G_BEGIN_DECLS
 
 #define SUBBASE2_TYPE                    (subbase2_get_type ())//该对象的类型
 #define SUBBASE2(o)                       (G_TYPE_CHECK_INSTANCE_CAST ((o), SUBBASE2_TYPE, Subbase2))//类型转换，转换为该对象的类型
 #define SUBBASE2_CLASS(k)                 (G_TYPE_CHECK_CLASS_CAST((k), SUBBASE2_TYPE, Subbase2Class))
 #define IS_SUBBASE2(o)                    (G_TYPE_CHECK_INSTANCE_TYPE ((o), SUBBASE2_TYPE))
 #define IS_SUBBASE2_CLASS(k)              (G_TYPE_CHECK_CLASS_TYPE ((k), SUBBASE2_TYPE))
 #define SUBBASE2_GET_CLASS(o)             (G_TYPE_INSTANCE_GET_CLASS ((o), SUBBASE2_TYPE, Subbase2Class))
 #define SUBBASE2_CAST(obj)              ((Subbase2*)(obj))
 
 typedef struct _Subbase2        Subbase2;
 typedef struct _Subbase2Class   Subbase2Class;
 typedef struct _Subbase2Private Subbase2Private;
 
 struct _Subbase2
 {
     Base    parent;
 };
 
 struct _Subbase2Class
 {
     BaseClass    parentclass;
 };
 
 GType                 subbase2_get_type  (void);
 Subbase2 *        subbase2_new(void);
 void                    subbase2_dance_dance(Subbase2    *self,char *dance);
 
 G_END_DECLS
 #endif /* ABSTRACTMODEL_H_ */

　　subbase2.c

 #include "subbase2.h"
 #include <string.h>
 
 //子类的宏定义，继承父类类型
 G_DEFINE_TYPE(Subbase2, subbase2, BASE_TYPE);
 
 #define GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SUBBASE2_TYPE, Subbase2))
 
 struct _Subbase2Private
 {
 };
 
 static void dispose_od(GObject *object);
 static void finalize_od(GObject *object);
 static void showSkill_od(Base *self);
 static char *getSkill_od(Base *self);
 
 static void subbase2_class_init(Subbase2Class *klass)
 {
     GObjectClass *object_class = G_OBJECT_CLASS(klass);
     g_type_class_add_private(klass, sizeof(Subbase2Private));
     object_class->dispose = dispose_od;
     object_class->finalize = finalize_od;
     BaseClass *baseClass = BASE_CLASS(klass);
     baseClass->getSkill=getSkill_od;
     baseClass->showKill=showSkill_od;
 }
 
 static void subbase2_init(Subbase2 *self)
 {
     Subbase2Private *priv = GET_PRIVATE(self);
 }
 
 static void dispose_od(GObject *object)
 {
     Subbase2 *self = SUBBASE2(object);
     Subbase2Private *priv = GET_PRIVATE(self);
 
     G_OBJECT_CLASS(subbase2_parent_class)->dispose(object);
 }
 
 static void finalize_od(GObject *object)
 {
     Subbase2 *self = SUBBASE2(object);
     Subbase2Private *priv = GET_PRIVATE(self);
 
     G_OBJECT_CLASS(subbase2_parent_class)->finalize(object);
 }
 static void showSkill_od(Base *self)
 {
     g_print("I ' m dancing\n");
 }
 static char *getSkill_od(Base *self)
 {
     return "dance";
 }
 
 Subbase2 *        subbase2_new(void)
 {
     Subbase2 *res = g_object_new(SUBBASE2_TYPE,NULL);
     return res;
 }
 void    subbase2_dance_dance(Subbase2    *self,char *dance)
 {
     g_print("I ' m dancing a %s dance!\n",dance);
 }

测试文件：main.c

 #include<glib.h>
 #include<stdio.h>
 #include<stdlib.h>
 #include"base.h"
 #include"subbase1.h"
 #include"subbase2.h"
 #include<string.h>
 
 int main(void)
 {
     g_print("hell world!\n");
     Subbase1 *test1 = subbase1_new();
     Subbase1 *test2 = subbase1_new();
     Subbase2 *test3 = subbase2_new();
 
     base_set_name(BASE(test1),"test1");
     base_set_name(BASE(test2),"test2");
     base_set_name(BASE(test3),"test3");
 
     g_print("name:%s\n",base_get_name(BASE(test1)));
     g_print("name:%s\n",base_get_name(BASE(test2)));
     g_print("name:%s\n",base_get_name(BASE(test3)));
 
     g_print("skill:%s\n",base_get_skill(BASE(test1)));
     base_show_skill(BASE(test1));
     g_print("skill:%s\n", base_get_skill(BASE(test3)));
     base_show_skill(BASE(test3));
 
     subbase1_sing_song(test1,"我怀恋的");
     subbase2_dance_dance(test3,"芭蕾");
 
     BASE(test1)->str = g_string_new("one");
     g_print("%s\n",BASE(test1)->str->str);
 
     return EXIT_SUCCESS;
 }

3、总结

　　如2的代码所示，其中涉及到了抽象、继承、重载等概念，C语言要使用面向对象来设计和解决问题，那么关于面向对象一般的基本特征也要了解和实现，要充分将这些实现方式转化为经验，这样再以后的面向对象设计中才能

驾轻就熟，也会更有效率。

　　同时如大家所见，C语言要实现面向对象这一特征是较为复杂的，代码相对JAVA或python等也非常的多，但是在嵌入式或一些需要使用C语言来设计和解决问题的领域，使用面向对象设计是有着很大的好处的，其中最明显的就是

可以减轻设计的复杂度。

4、题外话

　　在嵌入式领域C++的比重越来越来越大，著名的QT、openCV(一部分)等都是由C语言开发，C++开发嵌入式应用的效率上是有优势的，但是大部分的底层库还是得由C语言来实现，尤其是一些核心的东西需要C语言来支持

。