C++ Vector Enhancement

/*
Debug it to understand it, else it will crash and you won't get it why, you must restore the struct to avoid STL crash so can clean it when leave scope, also it was made for int (4 bytes) so you would have to replace the ASM part in Erase_By1_position (rep mosvd) and few things more, it is a sample to show you how you can do it, you loose memory or processing, your choice.
*/

#include <iostream>
#include <Windows.h>
#include <vector>
#include <list>

enum eModes
{
    m_1b = 1,
    m_2b = m_1b * 2,
    m_4b = m_2b * 2,
    m_8b = m_4b * 2
};

//testing purposes, did not use it
_declspec(naked) void M_memsetx4(DWORD Dest, DWORD Orig, DWORD zSize, DWORD Rev)
{
    _asm
    {
        push ebp
        mov ebp, esp
        sub esp, __LOCAL_SIZE

        nop
        int 3
        nop

        mov eax, Rev
        test eax, eax
        je _clear
        std
        jmp _logic

    _clear:
        cld
    _logic :
        mov ecx, zSize
        mov esi, Orig
        mov edi, Dest
        rep movsd

        mov esp, ebp
        pop ebp
        ret
    }
}

//testing purposes, did not use it
_declspec(naked) void M_memsetx1(DWORD Dest, DWORD Orig, DWORD zSize, DWORD Rev)
{
    _asm
    {
        push ebp
        mov ebp, esp
        ; sub esp, __LOCAL_SIZE

        nop
        int 3
        nop

        mov eax, Rev
        test eax, eax
        je _clear
        std
        jmp _logic

    _clear :
        cld
    _logic :
        mov ecx, zSize
        mov esi, Orig
        mov edi, Dest
        rep movsb

        mov esp, ebp
        pop ebp
        ret
    }
}

//testing purposes, did not use it
_declspec(naked) void asmfunc(DWORD Dest, DWORD Orig, DWORD zSize, DWORD Block)
{
    _asm
    {
        push ebp
        mov ebp, esp
        ; sub esp, __LOCAL_SIZE

        cld
        mov ecx, zSize
        mov esi, Orig
        mov edi, Dest

        cmp Block, 0x4
        jne _check_21
        rep movsd
        jmp _pass

    _check_21 :
        cmp Block, 0x2
        jne _check_1
        rep movsw
        jmp _pass

    _check_1 :
        rep movsb

    _pass :
        mov esp, ebp
        pop ebp
        ret
    }
}

//testing purposes, did not use it
void WINAPI M_memset(DWORD Dest, DWORD Orig, DWORD zSize, bool Rev)
{
    /*eModes Mode = eModes::m_2b; //movsw

    if (zSize % 2 == 1)
    {
        Mode = eModes::m_1b; //movsb
    }
    else if (zSize % 8 == 0)
    {
        Mode = eModes::m_8b; //movsq
    }
    else if (zSize % 4 == 0)
    {
        Mode = eModes::m_4b; //movsd
    }

    if (Mode == eModes::m_8b) Mode = eModes::m_4b;*/

    DWORD HardBlock;
    DWORD HardBlock_Mod;

    HardBlock = (int)(zSize / 4);
    HardBlock_Mod = zSize % 4;

    std::cout << "HardBlock: " << HardBlock << " (0x" << std::hex << HardBlock << ")" << std::endl;
    std::cout << "HardBlock_Mod: " << HardBlock_Mod << " (0x" << std::hex << HardBlock_Mod << ")" << std::endl;
    std::cout << std::hex << "Dest: " << Dest << std::endl;
    std::cout << std::hex << "Orig: " << Orig << std::endl;
    std::cout << std::hex << "zSize: " << zSize << std::endl;

    if (HardBlock > 0)
    {
        std::cout << "HardBlock" << std::endl;
        std::cin.get();

        M_memsetx4(Dest, Orig, HardBlock, Rev);
        if (HardBlock_Mod > 0) M_memsetx1(Orig, Dest, HardBlock_Mod, Rev);
    }
    else
    {
        std::cout << "By BYTE" << std::endl;
        std::cin.get();

        if (HardBlock_Mod > 0) M_memsetx1(Dest, Orig, HardBlock_Mod, Rev);
    }
    /*std::cout << std::hex << "Dest: " << Dest << std::endl;
    std::cout << std::hex << "Orig: " << Orig << std::endl;*/

    /*std::cin.get();
    __asm
    {
        nop
        int 3
        nop
    }*/
    //asmfunc(Dest, Orig, zSize / Mode, Mode);
    /*__asm
    {
        nop
        int 3
        nop
    }*/
}

//testing purposes, did not use it
void WINAPI M_memset2_Rev(DWORD Dest, DWORD Orig, DWORD zSize)
{
    for (int i = 0; i < zSize; i++)
    {
        /*std::cout << std::hex << "Dest: " << Dest << std::endl;
        std::cout << std::hex << "Orig: " << Orig << std::endl;

        std::cin.get();*/

        *(DWORD*)Dest = *(DWORD*)Orig;
        Dest -= 4;
        Orig -= 4;
    }

    //std::cout << "OUT" << std::endl;
    //std::cin.get();
}

//testing purposes, did not use it
void WINAPI M_memset2(DWORD Dest, DWORD Orig, DWORD zSize)
{
    for (int i = 0; i < zSize; i++)
    {
        /*std::cout << std::hex << "Dest: " << Dest << std::endl;
        std::cout << std::hex << "Orig: " << Orig << std::endl;

        std::cin.get();*/

        *(DWORD*)Dest = *(DWORD*)Orig;
        Dest += 4;
        Orig += 4;
    }

    //std::cout << "OUT" << std::endl;
    //std::cin.get();
}

DWORD ReadInProcessDWORD(DWORD Address)
{
    return *(DWORD*)Address;
}

enum eMode
{
    eVector,
    eList
};

eMode ArrayMode;

void PushAmount(std::vector<int>& vVector, std::list<int>& vList, DWORD vSize)
{
    switch (ArrayMode)
    {
        case eMode::eVector:
            for (DWORD i = 0; i < vSize; i++)
            {
                vVector.push_back(i);
            }

            break;
        case eMode::eList:
            for (DWORD i = 0; i < vSize; i++)
            {
                vList.push_back(i);
            }

            break;
        default:
            break;
    }
}

void Erase_By1_position(std::vector<int>& vVector, std::list<int>& vList, double vIndexPercent, DWORD vTimes, BOOL Enhancement = FALSE)
{
    DWORD Dest;
    DWORD Orig;
    DWORD zSize;
    DWORD Address;
    DWORD BkVal;
    std::list<int>::iterator it1;
    int mid;

    Address = (DWORD)&vVector;
    BkVal = *(DWORD*)(Address);

    switch (ArrayMode)
    {
        case eMode::eVector:
            for (int i = vTimes; i > 0; i--)
            {
                if (vIndexPercent == 0)
                {
                    if (Enhancement)
                    {
                        *(DWORD*)(Address) += 0x04;
                    }
                    else
                    {
                        vVector.erase(vVector.begin());
                    }
                }
                else
                {
                    if (vIndexPercent == 1)
                    {
                        vVector.erase(vVector.end() - 1);
                    }
                    else
                    {
                        if (Enhancement)
                        {
                            mid = (int)((vVector.size() - 1) * vIndexPercent);

                            //std::cout << "mid: " << mid << std::endl;

                            mid++;

                            if (vIndexPercent >= 0.50)
                            {
                                //M_memset2((*(DWORD*)(Address)) + (mid * sizeof(int)), (*(DWORD*)(Address)) + ((mid + 1) * sizeof(int)), (vVector.size() - 1) - mid);

                                Dest = (*(DWORD*)(Address)) + (mid * sizeof(int));
                                Orig = (*(DWORD*)(Address)) + ((mid + 1) * sizeof(int));
                                zSize = (vVector.size() - 1) - mid;

                                /*std::cout << std::hex << "Dest: " << Dest << std::endl;
                                std::cout << std::hex << "Orig: " << Orig << std::endl;
                                std::cout << std::hex << "zSize: " << zSize << std::endl;

                                std::cin.get();*/

                                /*for (int i = 0; i < zSize; i++)
                                {
                                    *(DWORD*)Dest = *(DWORD*)Orig;
                                    Dest += 4;
                                    Orig += 4;
                                }*/

                                __asm
                                {
                                    push ecx
                                    push esi
                                    push edi
                                    pushfd

                                    cld
                                    mov ecx, zSize
                                    mov edi, Dest
                                    mov esi, Orig
                                    rep movsd

                                    popfd
                                    pop edi
                                    pop esi
                                    pop ecx
                                }

                                *(DWORD*)(Address + 0x4) -= 0x04;
                            }
                            else
                            {
                                //M_memset((*(DWORD*)(Address)) + (mid * sizeof(int)), (*(DWORD*)(Address)) + ((mid - 1) * sizeof(int)), (mid - 1) * sizeof(int), true);
                                //M_memset2_Rev((*(DWORD*)(Address)) + (mid * sizeof(int)), (*(DWORD*)(Address)) + ((mid - 1) * sizeof(int)), mid);

                                Dest = (*(DWORD*)(Address)) + (mid * sizeof(int));
                                Orig = (*(DWORD*)(Address)) + ((mid - 1) * sizeof(int));
                                zSize = mid;

                                /*std::cout << std::hex << "Dest: " << Dest << std::endl;
                                std::cout << std::hex << "Orig: " << Orig << std::endl;
                                std::cout << std::hex << "zSize: " << zSize << std::endl;

                                std::cin.get();*/

                                /*for (int i = 0; i < zSize; i++)
                                {
                                    *(DWORD*)Dest = *(DWORD*)Orig;
                                    Dest -= 4;
                                    Orig -= 4;
                                }*/

                                __asm
                                {
                                    push ecx
                                    push esi
                                    push edi
                                    pushfd

                                    std
                                    mov ecx, zSize
                                    mov edi, Dest
                                    mov esi, Orig
                                    rep movsd

                                    popfd
                                    pop edi
                                    pop esi
                                    pop ecx
                                }

                                *(DWORD*)(Address) += 0x04;
                            }
                        }
                        else
                        {
                            mid = (int)((vVector.size() - 1) * vIndexPercent);
                            vVector.erase(vVector.begin() + mid);
                        }
                    }
                }
            }

            break;
        case eMode::eList:
            for (int i = vTimes; i > 0; i--)
            {
                if (vIndexPercent == 0)
                {
                    vList.pop_front(); //tList.erase(tList.begin()); //could be both
                }
                else
                {
                    if (vIndexPercent == 1)
                    {
                        it1 = vList.end();
                        --it1;
                        vList.erase(it1);
                    }
                    else
                    {
                        it1 = vList.begin();
                        mid = (int)((vList.size() - 1) * vIndexPercent);
                        std::advance(it1, mid);
                        vList.erase(it1);
                    }
                }
            }

            break;
        default:
            break;
    }
}

int main()
{
    ArrayMode = eMode::eVector;

    std::list<int> tList;
    //std::vector<int> tVec;
    std::vector<int> tVec;
    //std::vector<int>* tVec = new std::vector<int>;
    DWORD Address;
    DWORD BkVal;

    std::cin.get();

    DWORD GTC = GetTickCount();

    DWORD zSize = 0x05000000; //0x05000000;

    PushAmount(tVec, tList, zSize);

    if (tList.size() > 0) std::cout << tList.size() << " => " << GetTickCount() - GTC << std::endl;
    if (tVec.size() > 0) std::cout << tVec.size() << " => " << GetTickCount() - GTC << std::endl;

    Address = (DWORD)&tVec;
    BkVal = *(DWORD*)(Address);

    //std::cout << std::hex << &tVec << std::endl;
    //std::cout << std::hex << ReadInProcessDWORD(Address) << std::endl;

    //Address = ReadInProcessDWORD(Address);

    //std::cin.get();

    /*tVec->erase(tVec->begin());

    std::cin.get();*/

    //std::cout << std::hex << &tVec << std::endl;

    int TotSize = zSize / 0x010000;

    /* 0%
    Vector:
                83886080 => 359
                83884800 => 48187

            Enhancement
                83886080 => 312
                83884800 => 312
    List:
                83886080 => 4156
                83884800 => 4156
    */
    Erase_By1_position(tVec, tList, 0, TotSize, TRUE);

    /* 3%
    Vector:
                83886080 => 359
                83884800 => 48343

            Enhancement
                83886080 => 313
                83884800 => 1938
    List:
                83886080 => 4156
                83884800 => 14203
    */
    //Erase_By1_position(tVec, tList, 0.03, TotSize);

    /* 5%
    Vector:
                83886080 => 344
                83884800 => 46078

            Enhancement
                83886080 => 312
                83884800 => 3015
    List:
                83886080 => 4234
                83884800 => 20719
    */
    //Erase_By1_position(tVec, tList, 0.05, TotSize);

    /* 10%
    Vector:
                83886080 => 344
                83884800 => 43922

            Enhancement
                83886080 => 313
                83884800 => 5688
    List:
                83886080 => 4218
                83884800 => 37797
    */
    //Erase_By1_position(tVec, tList, 0.10, TotSize);

    /* 15%
    Vector:
                83886080 => 344
                83884800 => 42000

            Enhancement
                83886080 => 312
                83884800 => 8218
    List:
                83886080 => 4281
                83884800 => 53140
    */
    //Erase_By1_position(tVec, tList, 0.15, TotSize);

    /* 25%
    Vector:
                83886080 => 328
                83884800 => 35375

            Enhancement
                83886080 => 313
                83884800 => 13657
    List:
                83886080 => 4125
                83884800 => 84859
    */
    //Erase_By1_position(tVec, tList, 0.25, TotSize);

    /* 45%
    Vector:
                83886080 => 312
                83884800 => 25640

            Enhancement
                83886080 => 328
                83884800 => 24188
    List:
                83886080 => 4078
                83884800 => 147860
    */
    //Erase_By1_position(tVec, tList, 0.45, TotSize);

    /* 50%
    Vector:
                83886080 => 375
                83884800 => 23812

            Enhancement
                83886080 => 312
                83884800 => 23406
    List:
                83886080 => 4468
                83884800 => 172062
    */
    //Erase_By1_position(tVec, tList, 0.50, TotSize);

    /* 75%
    Vector:
                83886080 => 359
                83884800 => 12218

            Enhancement
                83886080 => 328
                83884800 => 11953
    List:
                83886080 => 4204
                83884800 => 239954
    */
    //Erase_By1_position(tVec, tList, 0.75, TotSize);

    /* 85%
    Vector:
                83886080 => 313
                83884800 => 7282

            Enhancement
                83886080 => 313
                83884800 => 7204
    List:
                83886080 => 4157
                83884800 => 280016
    */
    //Erase_By1_position(tVec, tList, 0.85, TotSize);

    /* 95%
    Vector:
                83886080 => 312
                83884800 => 2609

            Enhancement
                83886080 => 312
                83884800 => 2609
    List:
                83886080 => 4094
                83884800 => 295234
    */
    //Erase_By1_position(tVec, tList, 0.95, TotSize);

    /* 100%
    Vector:
                83886080 => 312
                83884800 => 312

            Enhancement
                83886080 => 313
                83884800 => 313
    List:
                83886080 => 4109
                83884800 => 4109
    */
    //Erase_By1_position(tVec, tList, 1, TotSize);

    /*for (it1 = tList.begin(); it1 != tList.end(); ++it1)
    std::cout << ' ' << *it1;*/

    //std::cout << "OUT" << std::endl;
    //std::cin.get();

    //4203ms

    if (tList.size() > 0)
    {
        std::cout << std::dec << tList.size() << " => " << GetTickCount() - GTC << std::endl;

        std::list<int>::iterator it_begin = tList.begin();
        std::list<int>::iterator it_last = tList.end();
        --it_last;
        std::cout << *it_begin << " - " << *it_last << std::endl;
    }

    if (tVec.size() > 0)
    {
        std::cout << std::dec << tVec.size() << " => " << GetTickCount() - GTC << std::endl;

        std::cout << tVec[0] << " - " << tVec[tVec.size() - 1] << std::endl;
        /*for (int i = 0; i < tVec.size(); i++)
        {
            std::cout << tVec[i] << " - ";
        }*/
    }

    //Misery working - Restore to avoid leak/crash
    *(DWORD*)(Address) = BkVal;

    std::cin.get();

    std::cout << "clearing and shrinking" << std::endl;
    tVec.clear();
    tVec.shrink_to_fit();

    std::cin.get();

    return 0;
}