cola.c

#include "colaPrivate.h"

/*publice method define*/
cola_t* cola_newObj()
{
    cola_t* self = (cola_t*)malloc(sizeof(cola_t));
    self->m_data = (cola_data_t*)malloc(sizeof(cola_data_t));
    self->m_vTable = (iDrink_vTable_t*)malloc(sizeof(iDrink_vTable_t));

    self->m_vTable->init = &cola_init;
    self->m_vTable->deleteObj = &cola_deleteObj;

    self->m_vTable->set_price = &cola_set_price;
    self->m_vTable->get_price = &cola_get_price;

    self->m_vTable->set_ice = &cola_set_ice;
    self->m_vTable->get_ice = &cola_get_ice;

    self->m_vTable->set_size = &cola_set_size;
    self->m_vTable->get_size = &cola_get_size;

    return self;
}

void cola_set_price(cola_t* self, int price)
{
    self->m_data->m_price = price;
}

int cola_get_price(cola_t* self)
{
    return self->m_data->m_price;
}

void cola_set_ice(cola_t* self, bool ice)
{
    self->m_data->m_ice = ice;
}

bool cola_get_ice(cola_t* self)
{
    return self->m_data->m_ice;
}

void cola_set_size(cola_t* self, int size)
{
    self->m_data->m_size = size;
}

int cola_get_size(cola_t* self)
{
    return self->m_data->m_size;
}

/*private method define*/
static void cola_init(cola_t* self)
{
    self->m_data->m_price = 0;
    self->m_data->m_ice = true;
    self->m_data->m_size = 0;
}

static void cola_deleteObj(cola_t* self)
{
    free(self->m_vTable);
    free(self->m_data);
    free(self);
}

cola.h

#pragma once
#include "common.h"

typedef struct _Cola_ cola_t;

/*publice method declaration*/
cola_t* cola_newObj();

void cola_set_price(cola_t* self, int price);
int cola_get_price(cola_t* self);

void cola_set_ice(cola_t* self, bool ice);
bool cola_get_ice(cola_t* self);

void cola_set_size(cola_t* self, int size);
int cola_get_size(cola_t* self);

colaPrivate.h

#pragma once
#include "cola.h"
#include "iDrink.h"

typedef struct _Cola_Data_ cola_data_t;

struct _Cola_{
    cola_data_t* m_data;
    iDrink_vTable_t* m_vTable;
};

/*private variable declaration*/
struct _Cola_Data_{
    int m_price;
    bool m_ice;
    int m_size;
};

/*private method declaration*/
static void cola_init(cola_t* self);
static void cola_deleteObj(cola_t* self);

common.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

iDrink.c

#include "iDrink.h"

void iDrink_init(iDrink_t* self)
{
    self->m_vTable->init(self);
}

void iDrink_deleteObj(iDrink_t* self)
{
    self->m_vTable->deleteObj(self);
}

void iDrink_set_price(iDrink_t* self, int price)
{
    self->m_vTable->set_price(self, price);
}

int iDrink_get_price(iDrink_t* self)
{
    return self->m_vTable->get_price(self);
}

void iDrink_set_ice(iDrink_t* self, bool ice)
{
    self->m_vTable->set_ice(self, ice);
}

bool iDrink_get_ice(iDrink_t* self)
{
    return self->m_vTable->get_ice(self);
}

void iDrink_set_size(iDrink_t* self, int size)
{
    self->m_vTable->set_size(self, size);
}

int iDrink_get_size(iDrink_t* self)
{
    return self->m_vTable->get_size(self);
}

iDrink.h

#pragma once
#include "common.h"
#define S_SIZE 1
#define M_SIZE 2
#define L_SIZE 3

typedef struct _i_Drink_ iDrink_t;

typedef struct _i_Drink_v_Table_{
    void (*init)(void*);
    void (*deleteObj)(iDrink_t*);

    void (*set_price)(iDrink_t*, int);
    int (*get_price)(iDrink_t*);

    void (*set_ice)(iDrink_t*, bool);
    bool (*get_ice)(iDrink_t*);

    void (*set_size)(iDrink_t*, int);
    int (*get_size)(iDrink_t*);
}iDrink_vTable_t;

struct _i_Drink_{
    void* m_data;
    iDrink_vTable_t* m_vTable;
};

void iDrink_init(iDrink_t* self);
void iDrink_deleteObj(iDrink_t* self);

void iDrink_set_price(iDrink_t* self, int price);
int iDrink_get_price(iDrink_t* self);

void iDrink_set_ice(iDrink_t* self, bool ice);
bool iDrink_get_ice(iDrink_t* self);

void iDrink_set_size(iDrink_t* self, int size);
int iDrink_get_size(iDrink_t* self);

main.c

#include "common.h"
#include "iDrink.h"
#include "cola.h"

int main()
{
    iDrink_t* m_cola = cola_newObj();
    iDrink_init(m_cola);

    iDrink_set_ice(m_cola, true);
    iDrink_set_size(m_cola, L_SIZE);
    iDrink_set_price(m_cola, 50);

    printf("prince: %d\n", iDrink_get_price(m_cola));
    printf("ice: %d\n", iDrink_get_ice(m_cola));
    printf("size: %d\n", iDrink_get_size(m_cola));

    iDrink_deleteObj(m_cola);

    return 0;
}