C语言也能面向对象（四）——继承

Technorati 标签: c, c语言, 面向对象, oo, object-oriented

本文版权所有，转载请注明出处和作者联系方式。
作者:孙华明
联系方式: wormsun at gmail.com

在C++中如果一个类有父类，那么这个类的对象中就包含了父类中定义的数据，并且可以使用父类的函数访问或操作该这些数据。在C中如何实现这样的机制呢？

animal类的定义如下：

typedef struct _animal animal;

struct _animal

{

/*class info*/

    klass_info* klass;

/*private data*/

    char name[256];

    int weight;

};

现在我们再定义一个dog类，除了包含animal类的属性外，还包括一个age属性，即年龄。如下：

typedef struct _dog dog ;

struct _dog 

{

/*class info*/

    klass_info* klass;

/*private data*/

    char name[256];

    int weight;

    int age;

};

在保持类的对象的内存布局不变的情况下，我们可以将dog类的定义变换为：

typedef struct _dog dog;

struct _dog

{

/*base*/

    animal base;

/*private data*/

    int age;

};

两个dog类的定义在内存布局上是完全一致的。因此，只要将dog类对象的指针强制转型为animal类的指针，那么animal类的成员函数就可以访问或操作 dog类对象了，如下：

dog* my_dog = lw_new(dog_klass);

animal_set_weight(ANIMAL(my_dog), 40);

int weight = animal_get_weight(ANIMAL(my_dog));

lw_delete(my_dog);

在C++中创建子类的对象时，要先调用父类的构造函数，然后再调用子类的函数；删除子类对象时，要先调用子类的析构函数，然后再调用父类的析构函数。

animal类是dog类的父类，在定义dog类信息时，要将dog类信息中的super属性初始化为animal类信息的地址，如下：

static klass_info local_dog_klass = 

{

    animal_klass,

    "dog_klass",

    sizeof(dog),

    dog_ctor,

    dog_dtor,

};

在实现dog的构造函数时，就可以使用类信息的super成员获取其父类的构造函数地址，如下：

static dog* dog_ctor(dog* self)

{

    ((voidf)(klass_of(self)->super->ctor))(self);

    self->age = 0;

    return self;

}

klass_of函数的功能是获取对象的类信息地址。可以看出dog类的构造函数是先调用父类的构造函数，然后再初始化子类的属性。类似，析构函数的实现如下：

static dog* dog_dtor(dog* self)

{

    ((voidf)(klass_of(self)->super->dtor))(self);

    return self;

}

目前为止，我们都是使用结构体初始化的方式来初始化类信息，这种方式有代码重复、容易犯错，难于维护的缺点，例如，animal类信息的初始化在animal.c中已经实现过，定义dog类时在dog.c中又要再次实现，如果再定义其他继承自animal类的子类，则还要实现。按顺序初始化结构体这种做法本身就很容易犯错，如果这样的代码到处都是，那么维护难度就可想而知了。

所以我们考虑使用类信息初始化函数来初始化类信息，即专门定义一个函数用来初始化类信息，该函数在程序运行后，第一次创建该类的对象时由lw_new函数调用。在类信息结构体中新加入一个属性，即类信息初始化函数的地址，如下：

typedef struct _klass_info klass_info;

struct _klass_info

{

    void* init; /*initialize function*/

    klass_info* super;    /*object's klass's super klass*/

    char* name; /*object's klass's name*/

    size_t size; /*object's size*/

    void* ctor; /*object's constructor*/

    void* dtor; /*object's destructor*/

};

init属性在定义静态类信息结构体对象时初始化，其他属性在init指向的函数中初始化，以animal类为例:

static animal_klass_info local_animal_klass = {animal_init};

animal_klass_info* animal_klass = &local_animal_klass;

void animal_init(void)

{

    if(animal_klass->init)

    {

        animal_klass->init = NULL;

        animal_klass->super = NULL;

        animal_klass->name = "animal_klass";

        animal_klass->size = sizeof(animal);

        animal_klass->ctor = animal_ctor;

        animal_klass->dtor = animal_dtor;

    }

}

lw_new函数修改如下：

void* lw_new(void* klass)

{

    klass_info* kls = KLASS(klass);

    if(kls->init)

    {

        ((init_fun)kls->init)();

    }

    void* p = malloc(kls->size);

    *((klass_info**)p) = kls;

    return ((voidf)(kls->ctor))(p);

}

类信息初始化函数中会将类信息结构体的init属性置空，所以该函数只会被调用一次，即第一次创建该类的对象时调用。

子类的类信息初始化函数可以直接调用父类的类信息初始化函数，以dog类为例：

void dog_init(void)

{

    if(dog_klass->init)

    {

        animal_init();

        memcpy(dog_klass, animal_klass, sizeof(animal_klass_info));

        dog_klass->super = animal_klass;

        dog_klass->name = "dog_klass";

        dog_klass->size = sizeof(dog);

        dog_klass->ctor = dog_ctor;

    }

}

至此我们实现了类继承，并使用类信息初始化函数来初始化类信息。

这里是相关代码。

下篇文章我们将讨论多态。