Поиск в занятой памяти процессом

DWORD ProcessID;
HANDLE Process;
 
PROCESSENTRY32 ProcessEntry;
 
bool ProcessTry(char* addres) {
    ProcessEntry.dwSize = sizeof(PROCESSENTRY32);
    HANDLE hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);
 
    do {
 
        if (!strcmp(ProcessEntry.szExeFile, addres)) {
            CloseHandle(hSnap);
 
            ProcessID = ProcessEntry.th32ProcessID;
            Process = OpenProcess(PROCESS_ALL_ACCESS, false, ProcessID);
            std::cout << "Process founded !";
            return true;
        }
 
    } while (Process32Next(hSnap, &ProcessEntry));
 
    CloseHandle(hSnap);
    std::cerr << "Process not found !" << std::endl;
    return false;
}

#include <iostream>
#include <string>
#include <exception>
#include <cstdlib>
#include <windows.h>
#include <tchar.h>
 
std::wstring getProtectString(DWORD protect)
{
    switch (protect)
    {
    case PAGE_READONLY:
        return std::wstring{ L"PAGE_READONLY" };
 
    case PAGE_READWRITE:
        return std::wstring{ L"PAGE_READWRITE" };
 
    case PAGE_WRITECOPY:
        return std::wstring{ L"PAGE_WRITECOPY" };
 
    case PAGE_EXECUTE_READ:
        return std::wstring{ L"PAGE_EXECUTE_READ" };
 
    case PAGE_EXECUTE_READWRITE:
        return std::wstring{ L"PAGE_EXECUTE_READWRITE" };
 
    case PAGE_EXECUTE_WRITECOPY:
        return std::wstring{ L"PAGE_EXECUTE_WRITECOPY" };
 
    case 0:
        return std::wstring{ L"PAGE_NOACCESS" };
 
    default:
        return std::wstring{ L"Unknown" };
    }
}
 
std::wstring getStateString(DWORD state)
{
    switch (state)
    {
    case MEM_COMMIT:
        return std::wstring{ L"MEM_COMMIT" };
 
    case MEM_RESERVE:
        return std::wstring{ L"MEM_RESERVE" };
 
    case MEM_FREE:
        return std::wstring{ L"MEM_FREE" };
 
    default:
        return std::wstring{ L"Unknown" };
    }
}
 
std::wstring getTypeString(DWORD type)
{
    switch (type)
    {
    case MEM_IMAGE:
        return std::wstring{ L"MEM_IMAGE" };
 
    case MEM_MAPPED:
        return std::wstring{ L"MEM_MAPPED" };
 
    case MEM_PRIVATE:
        return std::wstring{ L"MEM_PRIVATE" };
 
    default:
        return std::wstring{ L"Unknown" };
    }
}
 
int _tmain(int argc, TCHAR* argv[])
{
    void* pMemory = 0;
    std::wstring allocProtect;
    std::wstring protect;
    std::wstring state;
    std::wstring type;
    MEMORY_BASIC_INFORMATION memInfo;
 
    for (; VirtualQuery(pMemory, &memInfo, sizeof(memInfo));)
    {
        if (!memInfo.AllocationBase)
        {
            pMemory = (char*)pMemory + memInfo.RegionSize;
            continue;
        }
                
                // relies on copy elision
        allocProtect = getProtectString(memInfo.AllocationProtect);
        protect = getProtectString(memInfo.Protect);
        state = getStateString(memInfo.State);
        type = getTypeString(memInfo.Type);
 
        std::wcout << L"Allocation base: " << memInfo.AllocationBase << std::endl;
        std::wcout << L"Base address:" << memInfo.BaseAddress << std::endl;
        std::wcout << L"Region size: " << memInfo.RegionSize << L" bytes" << std::endl;
        std::wcout << L"Allocation protect: " << allocProtect << std::endl;
        std::wcout << L"Protect: " << protect << std::endl;
        std::wcout << L"State: " << state << std::endl;
        std::wcout << L"Type: " << type << std::endl << std::endl;
 
        pMemory = (char*)pMemory + memInfo.RegionSize;
    }
 
    std::wcin.get();
}