C++: la lecture de la mémoire d'un autre processus

J'aimerais avoir une fonction qui me permet de lire la mémoire d'un autre processus.
Je pensais à quelque chose comme ceci (pseudo-code):

staticAddress = 0x026E0DC4
processId = GetProcessIdByName(processName)
processHandle = GetProcessHandle(processId)
processBaseAddress = GetBaseAddress(processHandle)
addressToRead = processBaseAddress+staticAddress
readValueAsInt = ReadMemoryInt(processHandle, addressToRead)
readValueAsFloat = ReadMemoryFloat(processHandle, addressToRead)
readValueAsString = ReadMemoryString(processHandle, addressToRead)

Serait-ce même possible?
Voici ce que j'ai obtenu jusqu'à présent:

#include <Windows.h>
#include <conio.h>
#include <tlhelp32.h>
#include <string>
#include <psapi.h>
#pragma comment( lib, "psapi" )
int GetProcessId(char* ProcName) {
PROCESSENTRY32 pe32;
HANDLE hSnapshot = NULL;
pe32.dwSize = sizeof( PROCESSENTRY32 );
hSnapshot = CreateToolhelp32Snapshot( TH32CS_SNAPPROCESS, 0 );
if( Process32First( hSnapshot, &pe32 ) ) {
do {
if( strcmp( pe32.szExeFile, ProcName ) == 0 )
break;
} while( Process32Next( hSnapshot, &pe32 ) );
}
if( hSnapshot != INVALID_HANDLE_VALUE )
CloseHandle( hSnapshot );
return pe32.th32ProcessID;  
}
int GetModuleBase(HANDLE processHandle, string &sModuleName) 
{ 
HMODULE *hModules; 
char szBuf[50]; 
DWORD cModules; 
DWORD dwBase = -1; 
//------ 
EnumProcessModules(processHandle, hModules, 0, &cModules); 
hModules = new HMODULE[cModules/sizeof(HMODULE)]; 
if(EnumProcessModules(processHandle, hModules, cModules/sizeof(HMODULE), &cModules)) { 
for(int i = 0; i < cModules/sizeof(HMODULE); i++) { 
if(GetModuleBaseName(processHandle, hModules[i], szBuf, sizeof(szBuf))) { 
if(sModuleName.compare(szBuf) == 0) { 
dwBase = (DWORD)hModules[i]; 
break; 
} 
} 
} 
} 
delete[] hModules; 
return dwBase; 
}
int ReadMemoryInt(HANDLE processHandle, LPCVOID address) {
//LPVOID buffer = ??;
//SIZE_T size = ??;
SIZE_T NumberOfBytesToRead = 4; //??
ReadProcessMemory(processHandle, address, buffer, size, NumberOfBytesToRead)
return buffer; //??
}
int ReadMemoryFloat(HANDLE processHandle, LPCVOID address) {
//LPVOID buffer = ??;
//SIZE_T size = ??;
SIZE_T NumberOfBytesToRead = 8; //??
ReadProcessMemory(processHandle, address, buffer, size, NumberOfBytesToRead)
return buffer; //??
}
int ReadMemoryString(HANDLE processHandle, LPCVOID address) {
//LPVOID buffer = ??;
//SIZE_T size = ??;
SIZE_T NumberOfBytesToRead = 999; //??
ReadProcessMemory(processHandle, address, buffer, size, NumberOfBytesToRead)
return buffer; //??
}
int main()
{
//read an integer from "Program.exe"+0x05D8A3C4
int address = 0x05D8A3C4;
char* processName = "Program.exe";
int processId = GetProcessId(processName);
HANDLE processHandle = OpenProcess(PROCESS_ALL_ACCESS, false, processId);
int processBaseAddress = GetModuleBase(processHandle, (string)"Program.exe";
LPCVOID actualAddress = processBaseAddress+address;
int readValue = ReadMemory(processHandle, actualAddress);
std::cout << readValue << std::endl;
CloseHandle(processHandle);
return 0;
}

Comme vous pouvez le voir la forme de points d'interrogation dans le code que j'ai vraiment des doutes sur le "tampon" et "taille" paramètres de ReadProcessMemory. Je serais vraiment reconnaissant si quelqu'un pouvait m'aider à comprendre cela.