C语言利用 void 类型指针实现面向对象类概念与抽象。

不使用C++时，很多C语言新手可能认为C语言缺乏了面向对象和抽象性，事实上，C语言通过某种组合方式，可以间接性的实现面对对象和抽象。

不过多态和继承这种实现，就有点小麻烦，但是依然可以实现。

核心：

利用 void 类型指针，可以指向任意类型指针。

 //基本代码
 void* p;
 p = (void*) "HelloWorld";

 char* str;
 str = (char*) p;

 printf("%s",str);//输出 HellWord

通过这个我们就可以实现抽象性，让数据结构或函数不再与特定的类型高耦合。

从而像C++模板一样，处理任何类型元素。

面向对象的类概念：

类自身会有一组属性和一组公开或私有的方法函数，外界可以实例化一个，从而创建一个类的对象。

这在C语言里面，可以通过 struct 关键字来定义类似于类的概念结构。

我们现在来实现一组抽象的面向对象类的列表容器(List)，可以装载任意对象指针：

#include <stdio.h>
#include <stdlib.h>

#define SIEZ_NAME 200
#define Class struct 

//双向链表
typedef Class Struct_List_Node{
    void * item;
    struct Struct_List_Node * next;
    struct Struct_List_Node * previous;
}WList_Node;

typedef Class Struct_WList{
    //类的属性
    WList_Node* head;
    WList_Node* end;
    int length; 

    //公开方法函数
    void (*push)(Class Struct_WList*,void*);
    void (*destroy)(Class Struct_WList* );
    void* (*pop)(Class Struct_WList* );
    void* (*shift)(Class Struct_WList* );

}WList;

void WList_push(WList* self,void* item){
    WList_Node* new_node = (WList_Node* )malloc(sizeof(WList_Node));
    new_node->item = item;
    new_node->next = NULL;
    new_node->previous = NULL;
    printf("Push %p\n", new_node);
    self->length++;
    if(self->head == NULL){
        self->head = self->end = new_node;
    }else{
        new_node->previous = self->end;
        self->end = self->end->next = new_node;
    }

}

void* WList_pop(WList* self){
    if(self->length <=  )return NULL;
    WList_Node* pop_node;
    self->length--;
    pop_node = self->end;
    pop_node->previous->next = NULL;
    void* return_p = pop_node->item;
    free(pop_node);
    return return_p;

}

void* WList_shift(WList* self){
    if(self->length <=  )return NULL;
    WList_Node* pop_node;
    self->length--;
    pop_node = self->head;
    self->head = self->head->next;
    self->head->previous = NULL;
    void* return_p = pop_node->item;
    free(pop_node);
    return return_p;
}

void WList_destroy(WList* self){
    WList_Node* destroy_node;
    while(self->head){
        destroy_node = self->head;
        self->head = self->head->next;
        printf("WList_destroy: %p\n",destroy_node);
        free(destroy_node);
    }
}

void WList_init(WList* self){
    self->length = ;
    self->head = self->end = NULL;
    self->push = WList_push;
    self->pop = WList_pop;
    self->shift = WList_shift;
    self->destroy = WList_destroy;
}

//测试类型
typedef Class struct_book{
    char name[SIEZ_NAME];
    int price;
}Book;

int main(){
    //测试
    WList* list = (WList*) malloc(sizeof(WList));

    WList_init(list);

    list->push(list,"Head !");//C可以省略强制转换,但不建议
    list->push(list,(void *)'S');
    list->push(list,(void *));
    list->push(list,(void *));
    list->push(list,(void *)(char *) malloc(sizeof(char)*));
    list->push(list,(void *)"wc");
    list->push(list,(void *)(char *) malloc(sizeof(char)*));
    list->push(list,(void *)(char *) malloc(sizeof(char)*));
    list->push(list,(void *)(char *) malloc(sizeof(char)*));
    list->push(list,(void *)(Book *) malloc(sizeof(Book)*));
    list->push(list,(void *)"HelloWorld!!!!");

    printf("\nFrist List length:%d\n\n", list->length);
    printf("Head String: %s \n\n",(char *) list->shift(list));
    printf("End String: %s \n\n", list->pop(list));
    printf("List length:%d\n", list->length);

    list->destroy(list);

    getchar();
    return ;
}

这样我们就创建了解耦的通用列表容器。init相当于构造函数，destroy相当于析构函数。

仔细观察代码，编程list->xxx 即可以使用所有本身的公开函数，只是初始化的时候需要使用一下init函数。

然后我们每次将第一个参数作为自身传递，即可以像Python面向对象一样（虽然它自动传递），实现面向对象的类。

当然了，面向对象不止包括类，还有多态，抽象，接口，继承等等一系列行为，这些在C语言实现略为麻烦。

感谢耐心阅读。