#include <cstdint>
#include <Windows.h>
#include <iostream>

class Foo final
{
public:
    Foo() {}
    ~Foo() {}

    void Draw(char* arr, uint32_t ind)
    {
        arr[ind] = char(100);
    }
};

class Bar final
{
public:
    Bar() {}
    ~Bar() {}

    void Draw(char* arr, uint32_t ind)
    {
        arr[ind] = char(200);
    }
};

//===================================================================================================================================
#define MODE_FOO 0
#define MODE_BAR 1

union FooBar
{
    Foo* foo;
    Bar* bar;
};

void _DrawFoo(FooBar dr, char* arr, uint32_t ind)
{
    return dr.foo->Draw(arr, ind);
}

void _DrawBar(FooBar dr, char* arr, uint32_t ind)
{
    return dr.bar->Draw(arr, ind);
}

void(*__Draw)(FooBar dr, char* arr, uint32_t ind);

class Unvirtual
{
public:
    Unvirtual(int mode)
    {
        switch(mode)
        {
        case 0:
            mFooBar.foo = new Foo();
            __Draw = _DrawFoo;
            break;
        default:
            mFooBar.bar = new Bar();
            __Draw = _DrawBar;
            break;
        }
    }

    ~Unvirtual() {}

    void Draw(char* arr, uint32_t ind)
    {
        return __Draw(mFooBar, arr, ind);
    }

private:
    FooBar mFooBar;
};

class Virtual
{
public:
    Virtual() {}
    ~Virtual() {}

    virtual void Draw(char*, uint32_t) = 0;
};

class FooVirt: public Virtual
{
public:
    FooVirt()
    {
        mFoo = new Foo();
    }
    ~FooVirt()
    {
        delete mFoo;
    }

    void Draw(char* arr, uint32_t ind) override
    {
        return mFoo->Draw(arr, ind);
    }

private:
    Foo* mFoo;
};

class BarVirt: public Virtual
{
public:
    BarVirt()
    {
        mBar = new Bar();
    }
    ~BarVirt()
    {
        delete mBar;
    }

    void Draw(char* arr, uint32_t ind) override
    {
        return mBar->Draw(arr, ind);
    }

private:
    Bar* mBar;
};

int main()
{
    char *aaa = new char[1000000000];

    __int64 freq;
    QueryPerformanceFrequency((LARGE_INTEGER*)&freq);
    __int64 start, end;

    Unvirtual unvirt(MODE_FOO);
    QueryPerformanceCounter((LARGE_INTEGER*)&start);
    for(uint32_t i = 0; i < 1000000000; i++)
    {
        unvirt.Draw(aaa, i);
    }
    QueryPerformanceCounter((LARGE_INTEGER*)&end);

    double t1 = (double)(end - start) / freq;

    Virtual* virt = new FooVirt();
    QueryPerformanceCounter((LARGE_INTEGER*)&start);
    for(uint32_t i = 0; i < 1000000000; i++)
    {
        virt->Draw(aaa, i);
    }
    QueryPerformanceCounter((LARGE_INTEGER*)&end);

    double t2 = (double)(end - start) / freq;

    std::cout << "Unvirtual time: " << t1 << std::endl;
    std::cout << "Virtual time:   " << t2 << std::endl;
    std::cin.get();

    delete[] aaa;
}