#include<iostream>

using namespace std;

class Demo
{
protected:    
    int mi;
    int mj;
public:
    virtual void print()
    {
        cout << "mi = " << mi <<","
             << "mj = " << mj << endl;
    }
};

class Derived : public Demo
{
private:
    int mk;
public:
    Derived(int i, int j, int k)
    {
        mi = i;
        mj = j;
        mk = k;
    }

    void print()
    {
        cout << "mi = " << mi << ","
             << "mj = " << mj << ","
             << "mk = " << mk << endl;
    }
};

struct Test
{
    void* p;
    int mi;
    int mj;
    int mk;
};

int main()
{
    cout << "sizeof(Demo) = " << sizeof(Demo) << endl;//12而不是8，原因：在类里边塞入了一个指向虚函数表的指针
    cout << "sizeof(Derived) = " << sizeof(Derived) << endl;//16而不是12

    Derived d(1, 2, 3);
    struct Test *p = reinterpret_cast<Test*>(&d);//说明结构体和对象的内存分布相同，第一个为指向虚函数表的指针，后面依次是mi、mj、mk

    cout << "Before Chinging..." << endl;
    d.print();//mi = 1, mj = 2, mk = 3

    p->mi = 10;
    p->mj = 20;
    p->mk = 30;
    
    cout << "After Chinging..." << endl;
    d.print();//mi = 10, mj = 20, mk = 30
    return 0;
}

#ifndef _ADD_H_
#define _ADD_H_

typedef void Demo;
typedef void Derived;

Demo* Demo_create(int i, int j);
int Demo_GetI(Demo* pThis);
int Demo_GetJ(Demo* pThis);
int Demo_add(Demo* pThis, int value);
void Demo_free(Demo* pThis);

Derived* Derived_create(int i, int j, int k);
int Derived_GetK(Derived* pThis);
int Derived_add(Derived* pThis, int value);//重写add函数

#endif

#include"add.h"
#include<malloc.h>

static int Demo_virtual_add(Demo* pThis, int value);
static int Derived_virtual_add(Demo* pThis, int value);

struct VTable
{
    int (*pAdd)(void*, int);//2.定义虚函数表结构体并且填充相应的虚函数指针
};

struct ClassDemo
{
    struct VTable *ptr;//1.在类中定义指向虚函数表的指针
    int mi;
    int mj;
};

struct ClassDerived
{
    struct ClassDemo d;
    int mk;
};

static struct VTable Demo_virtual_table = {Demo_virtual_add};//3.生成子类和父类的虚函数表,由c++知虚函数表由编译器使用，故模拟时加上static关键字
static struct VTable Derived_virtual_table = {Derived_virtual_add};//3

//Demo父类
Demo* Demo_create(int i, int j)
{
    struct ClassDemo* ret = malloc(sizeof(struct ClassDemo));
    
    if(ret != NULL)
    {
        ret->ptr = &Demo_virtual_table;//4.关联具体对象与虚函数表
        ret->mi = i;
        ret->mj = j;
    }

    return ret;
}

int Demo_GetI(Demo* pThis)
{
    struct ClassDemo* ret = (struct ClassDemo *)(pThis);
    
    return ret->mi;
}

int Demo_GetJ(Demo* pThis)
{
    struct ClassDemo* ret = (struct ClassDemo *)(pThis);

    return ret->mj;
}

static int Demo_virtual_add(Demo* pThis, int value)//5.实现真正的虚函数
{
    struct ClassDemo* ret = (struct ClassDemo *)(pThis);

    return (ret->mi + ret->mj + value);
}

int Demo_add(Demo* pThis, int value)
{
    struct ClassDemo* ret = (struct ClassDemo *)(pThis);

    return ret->ptr->pAdd(pThis, value);//6.改造虚函数的接口
}

void Demo_free(Demo* pThis)
{
    free(pThis);
}

//Derived子类
Derived* Derived_create(int i, int j, int k)
{
    struct ClassDerived* ret = malloc(sizeof(struct ClassDerived)); 
    if(ret != NULL)
    {
        ret->d.ptr = &Derived_virtual_table;
        ret->d.mi = i;
        ret->d.mj = j;
        ret->mk = k;
    }
    return ret;
}

int Derived_GetK(Derived* pThis)
{
    struct ClassDerived* ret = (struct ClassDerived*)(pThis);

    return ret->mk;
}

static int Derived_virtual_add(Demo* pThis, int value)
{
    struct ClassDerived* ret = (struct ClassDerived*)(pThis);

    return ret->mk + value;
}

int Derived_add(Derived* pThis, int value)
{
    struct ClassDerived* ret = (struct ClassDerived*)(pThis);

    return ret->d.ptr->pAdd(pThis, value);
}

#include<stdio.h>
#include<malloc.h>
#include"add.h"

void run(Demo* p, int v)
{
    int r = Demo_add(p, v);//模仿c++，默认调用父类的成员函数
    printf("run(p,v) = %d\n", r);
}

int main()
{
    Demo* pb = Demo_create(1, 2);
    Derived* pd = Derived_create(4, 5, 6);

    
    printf("Demo_add(pb,3) = %d\n", Demo_add(pb, 3));//1+2+3=6
    printf("Derived_add(pd,3) = %d\n", Derived_add(pd, 3));//6+3=9

    run(pb, 3);//1+2+3=6
    run(pd, 3);//6+3=9 ===>Demo_add(pd,3)===>return pd->ptr->pAdd(pd, 3)====>又 pd->ptr = &Demo_virtual_table

    Demo_free(pb);
    Demo_free(pd);//继承父类的析构函数 

    return 0;
 }