template<class T>
std::string variableToStr(const T &v)
{
	try
	{
		StrStream ss;
		ss<<v;
		string r=ss.str();
		return r;
	}
	catch(...)
	{
	}
	return "*failed-to-parse*";
}

template<class T>
std::string variableToStr(const T &v)
{
	//try
	//{
	//	StrStream ss;
	//	ss<<v;
	//	string r=ss.str();
	//	return r;
	//}
	//catch(...)
	//{
	//}
	return "*failed-to-parse*";
}

#include "stdafx.h"
#include <iostream>
#include <fstream>
#include <string>
#include <sstream>
using namespace std;

class StrStream
{
	std::stringbuf _buffer;             // empty buffer
	std::ostream _os;      // associate stream buffer to stream
public:
	StrStream():_os(&_buffer)
	{
	}
	template<typename T>
	StrStream &operator<<(const T &v)
	{
		try
		{
			_os<<v;
		}
		catch(...)
		{
			try
			{
				_os<<"*failed*";
			}
			catch(...)
			{

			}
		}
		return *this;
	}
	std::string str()const
	{
		return _buffer.str();
	}
};


int main(int argc, char* argv[])
{
	string* buf=(string*)0x00F0000;
	try
	{
		StrStream ss;
		ss<<*buf;
		string sss=ss.str();
	}
	catch(...)
	{
		cout<<"opa"<<endl;
	}
	cout<<"ok"<<endl;

	getchar();
	return 0;
}

int main(int argc, char* argv[])
{
	string* buf=(string*)0x00F0000;
	try
	{
		string tmp=*buf;
	}
	catch(...)
	{
		cout<<"opa"<<endl;
	}
	cout<<"ok"<<endl;
	getchar();
	return 0;
}

string* buf=(string*)0x00F0000;

//---------------------------------------------
Exe
func(HANDLE h)//original
{

}

//---------------------------------------------
Dll

template<typename T>
void handle_1(const T &v)
{
...
   list<string> params;
   params.push_back(variableToStr(v));
...
}

func(HANDLE h)//hook
{
   handle_1(h);
}

	string* buf=(string*)0x00F0000;
	if(IsBadReadPtr(buf, sizeof(string))) {
		cout<<"bad ptr"<<endl;
	} else {
...

	StrStream &operator<<(const T &v)
	{
		if(IsBadReadPtr(&v, sizeof(T))) {
			cout<<"bad ptr 2"<<endl;
		} else {
...

std::string WStrToStr(const std::wstring& s)  
{  
    std::string temp(s.length(), ' ');  
    std::copy(s.begin(), s.end(), temp.begin());  
    return temp;  
}  

template<>
StrStream &StrStream::operator<<(const PCWSTR &s)
{
	try
	{
		_os<<"L\""<<WStrToStr(s)<<"\"";
	}
	catch(...)
	{
		_os<<"*failed-to-write(PCWSTR)*";
	}
	return *this;
}