C语言面向对象-类

第一种方式：
.h文件，结构定义数据成员，提供函数接口
.c文件，实现接口
实际上是模块化编程，基于对象模式，不能够封装，继承等


第二种方式：
.h文件，数据成员和操作定义在一个结构体，操作用函数指针表示
.c文件，定义实现操作函数
基本上对象的面向对象，可以实现继承，多态，但是封装不够好，能够直接访问和操作成员变量

第三种方式：
.h文件，结构中定义操作结构
.c，定义一个机构专门用于存储私有成员和操作
做到真正封装，可以实现继承，多态，便于使用各种设计模式


相关实例代码

queue.h:

#ifndef _QUEUE_H
#define _QUEUE_H


#define QUEUE_SIZE      20
typedef struct Queue Queue;
typedef struct Queue* PQueue;
//typedef int (* WNDPROC)(HWND, int, WPARAM, LPARAM);
typedef int  (*IsFullFunc)(const PQueue);
typedef int  (*IsEmptyFunc)(const PQueue);
typedef int  (*InsertFunc)(PQueue const, int);
typedef int  (*RemoveFunc)(PQueue const);
struct Queue
{
#if 0
    // data
    char buf[QUEUE_SIZE];
    int  head;
    int  size;
    int  tail
#endif


    // method
    int  (*isFull)(const PQueue me);
    int  (*isEmpty)(const PQueue me);
    int  (*getSize)(const PQueue me);
    int  (*insert)(PQueue const me, int val);
    int  (*remove)(PQueue const me);


};


// operations
// create and destroy
PQueue Queue_Create();
void Queue_Destroy();


#endif


queue.c:

#include "Queue.h"
#include "includes.h"


#define DeclarePrv(me) PQueuePrv prv = (PQueuePrv)((INT8U*)me+sizeof(Queue));
typedef struct QueuePrv QueuePrv;
typedef struct QueuePrv * PQueuePrv;
struct QueuePrv
{
    char buf[QUEUE_SIZE];
    int  head;
    int  size;
    int  tail;
};




// operations
static int isEmpty(const PQueue me)
{
    DeclarePrv(me);
    return prv->head == prv->tail;
}


static int isFull(const PQueue me)
{
    DeclarePrv(me);
    //取余，good
    return (prv->head+1)%QUEUE_SIZE == prv->tail;


}


static int getSize(const PQueue me)
{
    DeclarePrv(me);
    return prv->size;
}


static int insert(PQueue const me, int val)
{
    DeclarePrv(me);
    if (!me->isFull(me))
    {
        prv->buf[prv->head] = val;
        prv->head = (prv->head+1)%QUEUE_SIZE;
        ++prv->size;
    }
    return 0;
}


static int remove(PQueue const me)
{
    int value = -9999;
    DeclarePrv(me);
    if (!me->isEmpty(me))
    {
        value = prv->buf[prv->tail];
        prv->tail = (prv->tail+1)%QUEUE_SIZE;
        --prv->size;
    }
    return value;
}


// constructor and destructor
static void Queue_Init(PQueue const me,
                       int  (*isEmpty)(const PQueue me),
                       int  (*isFull)(const PQueue me),
                       int  (*getSize)(const PQueue me),
                       int  (*insert)(PQueue const me, int val),
                       int  (*remove)(PQueue const me))
{
    DeclarePrv(me);
    memset(prv, 0, sizeof(QueuePrv));
    
    me->isEmpty = isEmpty;
    me->isFull = isFull;
    me->getSize = getSize;
    me->insert = insert;
    me->remove = remove;
    
}
static void Queue_Cleanup(PQueue const me)
{
    
}




// create and destroy
PQueue Queue_Create()
{
    PQueue me = (PQueue)malloc(sizeof(Queue) + sizeof(QueuePrv));
    if (me != NULL)
    {
        Queue_Init(me, isEmpty, isFull, getSize, insert, remove);
    }
    return me;
}
void Queue_Destroy(PQueue me)
{
    if (me != NULL)
    {
        Queue_Cleanup(me);
        free(me);
    } 
}

test.c:
#include <stdio.h>
#include <stdlib.h>
#include "Sensor.h"
#include "Queue.h"

void Queue_Test()
{
    int i = 0;
    PQueue pQue = Queue_Create();
    for (; i<10; i++)
    {
        pQue->insert(pQue, i);
    }


    for (i=pQue->getSize(pQue); i--; i>=0)
    {
        printf("pos %d, value=%d\n", i, pQue->remove(pQue));
    }


    printf("size = %d \n", pQue->getSize(pQue));
}




int main()
{
    //Sensor_Test();
    Queue_Test();
    return 0;
};