Problem z czytaniem pamięci (std::string)

First-chance exception at 0x0FA0CCC8 (msvcp110d.dll) in XXX.exe: 0xC0000005: Access violation reading location 0x65746E49.
Unhandled exception at 0x0FA0CCC8 (msvcp110d.dll) in XXX.exe: 0xC0000005: Access violation reading location 0x65746E49.

#include "Memory.h"

Memory::Memory(const char* ClassName)
{
	this->h_HWND = FindWindow(ClassName, NULL);
	GetWindowThreadProcessId(this->h_HWND, &this->h_PID);
	this->h_Process = OpenProcess(PROCESS_ALL_ACCESS, FALSE, this->h_PID);
}

Memory::~Memory(void)
{
	this->h_HWND = NULL;
	this->h_PID = NULL;

	if (this->h_Process != 0x00000000)
		CloseHandle(this->h_Process);
}

#pragma once

class Memory
{
public:
	Memory(const char* ClassName);
	template <class T> bool Read(unsigned int Offset, T& Value)
	{
		SIZE_T size = 1024;
		SIZE_T sizeRead;
		bool valid;

		valid = ReadProcessMemory(this->h_Process, (LPCVOID)Offset, (LPVOID)&Value, size, &sizeRead) ? true : false;

		if(valid == false || sizeRead != size){
			return false;
		}

		return true;
	}
	virtual ~Memory(void);
private:
	HANDLE h_Process;
	DWORD h_PID;
	HWND h_HWND;
};

if(valid == false || sizeRead != size){

if((!valid) || sizeRead != size){	

template <class T> bool Write(unsigned int Offset, const T* Value)
	{
		SIZE_T size = strlen(Value);

		SIZE_T sizeRead;
		bool valid;

		valid = WriteProcessMemory(this->h_Process, (LPVOID)Offset, (LPCVOID)&Value, size, &sizeRead);

		if((!valid) || sizeRead != size){
			std::cout << "Błąd" << std::endl;
			return false;
		}

		return true;

#include "ProcessMemory.hpp"

#include <memory>
#include <string>

#include <Windows.h>
#include <assert.h>

struct Test
{
	char Values[16];

	Test()
	{
		for(int i = 0; i < 16; i++)
			Values[i] = rand() % 256;
	}

	bool IsEqualTo(const Test& another)
	{
		for(int i = 0; i < 16; i++)
		{
			if(Values[i] != another.Values[i])
				return false;
		}

		return true;
	}
};

int main()
{
	ProcessMemory processMemory(GetCurrentProcessId());

	{
		double original = 3.14;
		double retrieved = processMemory.Read<double>(&original);

		assert(original == retrieved);
	}

	{
		Test original;
		std::unique_ptr<Test> retrieved = processMemory.Read<Test*>(&original);

		assert(retrieved->IsEqualTo(original));
	}

	{
		Test originals[5];
		std::unique_ptr<Test[]> retrieved = processMemory.Read<Test[]>(originals, 5);

		for(int i = 0; i < 5; i++)
			assert(retrieved[i].IsEqualTo(originals[i]));
	}

	{
		double original = 3.14;
		double placeholder;
		
		processMemory.Write(&placeholder, original);

		assert(original == placeholder);
	}

	{
		Test originals[5];
		auto placeholder = std::unique_ptr<Test[]>(new Test[5]);

		processMemory.Write(placeholder.get(), originals);

		for(int i = 0; i < 5; i++)
			assert(placeholder[i].IsEqualTo(originals[i]));
	}

	{
		const char* original = "testowy napis";

		std::unique_ptr<char[]> retrieved = processMemory.Read<char[]>(original, strlen(original) + 1);

		assert(strcmp(original, retrieved.get()) == 0);
	}

	{
		std::string original = "testowy napis";
		std::string retreived = processMemory.Read<char[]>(&original[0], original.size() + 1).get();

		assert(original == retreived);
	}

	return 0;
}

#pragma once

#include <Windows.h>

#include <memory>
#include <exception>

#include <boost\type_traits\is_pointer.hpp>
#include <boost\type_traits\is_array.hpp>
#include <boost\type_traits\remove_pointer.hpp>
#include <boost\type_traits\remove_bounds.hpp>
#include <boost\utility\enable_if.hpp>

class ProcessMemory
{
private:
	HANDLE _processHandle;

	bool IsValidHandle(HANDLE handle)
	{
		return handle != NULL && handle != INVALID_HANDLE_VALUE;
	}

public:
	ProcessMemory(int processId)
	{
		_processHandle = OpenProcess(PROCESS_VM_READ | PROCESS_VM_WRITE | PROCESS_VM_OPERATION, false, processId);

		if(!IsValidHandle(_processHandle)) throw std::exception();
	}

	~ProcessMemory()
	{
		if(IsValidHandle(_processHandle))
		{
			CloseHandle(_processHandle);
			_processHandle = NULL;
		}
	}

	void Read(LPCVOID address, LPVOID buffer, SIZE_T size)
	{
		SIZE_T bytesRead;

		if(ReadProcessMemory(_processHandle, address, buffer, size, &bytesRead) == 0)
			throw std::exception();

		if(bytesRead != size)
			throw std::exception();
	}

	template<typename T>
	T Read(LPCVOID address, ...)
	{
		T object;

		Read(address, &object, sizeof(T));

		return object;
	}

	template<typename T>
	std::unique_ptr<typename boost::remove_pointer<T>::type>
	Read(LPCVOID address, typename boost::enable_if<boost::is_pointer<T>>::type* dummy = 0)
	{
		typedef boost::remove_pointer<T>::type TType;

		TType* object = new TType;
		
		try
		{
			Read(address, object, sizeof(TType));
		}
		catch(...)
		{
			delete object;

			throw;
		}

		return std::unique_ptr<TType>(object);
	}

	template<typename T>
	std::unique_ptr<T> Read(LPCVOID address, size_t elementCount, typename boost::enable_if<boost::is_array<T>>::type* dummy = 0)
	{
		typedef boost::remove_bounds<T>::type TType;

		TType* objects = new TType[elementCount];
		
		try
		{
			Read(address, objects, sizeof(TType) * elementCount);
		}
		catch(...)
		{
			delete[] objects;

			throw;
		}

		return std::unique_ptr<TType[]>(objects);
	}

	void Write(LPVOID address, LPCVOID buffer, SIZE_T size)
	{
		SIZE_T bytesWritten;

		if(WriteProcessMemory(_processHandle, address, buffer, size, &bytesWritten) == 0)
			throw new std::exception;

		if(bytesWritten != size)
			throw std::exception();
	}

	template<typename T>
	void Write(LPVOID address, const T &object)
	{
		Write(address, &object, sizeof(T));
	}

	template<typename T, size_t elementCount>
	void Write(LPVOID address, T (&objects)[elementCount])
	{
		Write(address, &objects, sizeof(objects));
	}
};

throw new std::exception;

throw std::runtime_error ("ProcessMemory.Write failed");

template <class T> bool Sprawdz(T typ)
{
if (T == char) // CHODZI DOKŁADNIE TUTAJ, JEST JAKIŚ SPOSÓB NA TO?
{
std::cout << "Typ: CHAR" << std::endl;
}
else
{
std::cout << "Typ: INNY" << std::endl;
}
}

        if(bytesWritten != size)
                throw new std::exception;

template <class T> bool Sprawdz() {
    std::cout << "Typ: INNY" << std::endl;
}

template <> bool Sprawdz<char>()
{
    std::cout << "Typ: CHAR" << std::endl;
}

template<class T> bool Read(unsigned int Address, const T* Buffer)
		{
			SIZE_T bytesRead;
			SIZE_T size = sizeof(T);

			if(typeid(T) == typeid(char))
				size = strlen(*Buffer) + 1;
 
			if(ReadProcessMemory(_processHandle, (LPCVOID)Address, (LPVOID)Buffer, size, &bytesRead) == 0)
                throw new std::exception;
 
			if(bytesRead != size)
                throw new std::exception;
		}

// TiBot.cpp: Określa punkt wejścia dla aplikacji konsoli.
//

#include "stdafx.h"
#include "ProcessMemory.h"

/* Moje notatki:
Mając wskaźnik & możemy bezpośrednio odczytać z niego wartość.
Mając wskaźnik * musimy podać mu adres i wtedy można odczytać z niego wartość przed zmienną dodawając *.

	int i = 0;
	int* x = &i;
	int& z = i;
	int& y = *x;
	int* w = &y;

	std::cout << i << std::endl; // Wartość
	std::cout << *x << std::endl; // Wartość
	std::cout << z << std::endl; // Wartość
	std::cout << y << std::endl; // Wartość
	std::cout << *w << std::endl; // Wartość

	std::cout << &i << std::endl; // Adres
	std::cout << x << std::endl; // Adres
	std::cout << &z << std::endl; // Adres
	std::cout << &y << std::endl; // Adres
	std::cout << w << std::endl; // Adres
*/

int main(int argc, char* argv[])
{
	try
	{
		boost::scoped_ptr<ProcessMemory> pm (new ProcessMemory("TibiaClient"));
		char string;	
		pm->Read(0x0064004C, &string);
		std::cout << string << std::endl;
	}
	catch(std::exception& ex)
	{
		MessageBox(NULL, ex.what(), "TEST", 0);
	}
	system("pause");
	return 0;
}

			SIZE_T size = sizeof(T);

			if(typeid(T) == typeid(char))
				size = strlen(*Buffer) + 1;

foo(&x);

// TiBot.cpp: Określa punkt wejścia dla aplikacji konsoli.
//

#include "stdafx.h"
#include "ProcessMemory.h"

/*
Mając referencje & możemy bezpośrednio odczytać z niego wartość.
Mając wskaźnik * musimy podać mu adres i wtedy można odczytać z niego wartość przed zmienną dodawając *.

	int i = 0;
	int* x = &i;
	int& z = i;
	int& y = *x;
	int* w = &y;

	std::cout << i << std::endl; // Wartość
	std::cout << *x << std::endl; // Wartość
	std::cout << z << std::endl; // Wartość
	std::cout << y << std::endl; // Wartość
	std::cout << *w << std::endl; // Wartość

	std::cout << &i << std::endl; // Adres
	std::cout << x << std::endl; // Adres
	std::cout << &z << std::endl; // Adres
	std::cout << &y << std::endl; // Adres
	std::cout << w << std::endl; // Adres
*/

int main(int argc, char* argv[])
{
	try
	{
		boost::scoped_ptr<ProcessMemory> pm (new ProcessMemory("TibiaClient"));
		char string[256];	
		pm->Read(0x0064004C, string);
		std::cout << string << std::endl;
		pm->Write(0x0064004C, "MateuszX");
	}
	catch(std::exception& ex)
	{
		MessageBox(NULL, ex.what(), "TEST", 0);
	}
	system("pause");
	return 0;
}

#pragma once
 
class ProcessMemory
{
private:
        HANDLE _processHandle;
 
        bool IsValidHandle(HANDLE handle);
 
public:
        ProcessMemory(const char* ClassName);
 
        ~ProcessMemory();

		template<class T> bool Read(unsigned int Address, T& Buffer)
		{
			SIZE_T bytesRead;
			SIZE_T size = sizeof(Buffer);
 
			if(ReadProcessMemory(_processHandle, (LPCVOID)Address, (LPVOID)&Buffer, size, &bytesRead) == 0)
                throw std::runtime_error ("ProcessMemory.ReadMemoryProcess failed");
 
			if(bytesRead != size)
                throw std::runtime_error ("ProcessMemory.Read.bytes!=size failed");

			return true;
		}

		template<class T> bool Write(unsigned int Address, const T& Buffer)
		{
			SIZE_T bytesWritten;
			SIZE_T size = sizeof(T);

			if(WriteProcessMemory(_processHandle, (LPVOID)Address, (LPCVOID)&Buffer, size, &bytesWritten) == 0)
                throw std::runtime_error ("ProcessMemory.WriteMemoryProcess failed");
 
			if(bytesWritten != size)
                throw std::runtime_error ("ProcessMemory.Write.bytes!=size failed");

			return true;
		}

		template<> bool Write<char>(unsigned int Address, const char& Buffer)
		{
			SIZE_T bytesWritten;
			SIZE_T size = strlen(&Buffer) + 1;

			if(WriteProcessMemory(_processHandle, (LPVOID)Address, (LPCVOID)&Buffer, size, &bytesWritten) == 0)
                throw std::runtime_error ("ProcessMemory.WriteMemoryProcess failed - CHAR");
 
			if(bytesWritten != size)
                throw std::runtime_error ("ProcessMemory.Write.bytes!=size failed - CHAR");

			return true;
		}
};

< char *>