简单转换宽窄字符

调用如：CStringW strW = TtoW(_T("开始转换吧，简单：）");

#pragma once

#include 
 
 
  
  

//
//  Code Page Default Values.
//
/*
//in 
  
  
   
   
#define CP_ACP                    0           // default to ANSI code page
#define CP_OEMCP                  1           // default to OEM  code page
#define CP_MACCP                  2           // default to MAC  code page
#define CP_THREAD_ACP             3           // current thread's ANSI code page
#define CP_SYMBOL                 42          // SYMBOL translations

#define CP_UTF7                   65000       // UTF-7 translation
#define CP_UTF8                   65001       // UTF-8 translation
*/

#define CP_JAP			932		//日文        SHIFTJIS_CHARSET
#define CP_ZH_CN		936		//中文(简体)  GB2312_CHARSET      Chinese Simplified	
#define CP_KSC			949		//韩文        HANGUL_CHARSET	
#define CP_ZH_TW		950		//中文(繁体)  CHINESEBIG5_CHARSET Chinese Traditioal	

#define CP_UNICODE		1200    //Little-Endian
#define CP_UNICODE_BE	1201    //Big-Endian


template
   
   
    
    
class memAlloc
{
public:
	memAlloc() : m_length(nSizeOnStack), m_bufOnHeap(NULL), m_p(m_bufOnStack) {}
	~memAlloc() { _free(); }

	void* getBuffer(unsigned int nNewSize, bool bKeepContent = false, bool bZeroMemory = false)
	{
		if (nNewSize > m_length)
		{
			if (m_bufOnHeap == NULL)
				m_bufOnHeap = malloc(nNewSize);
			else
				m_bufOnHeap = realloc(m_bufOnHeap, nNewSize);

			if (m_bufOnHeap == NULL)
				throw std::bad_alloc("out of memory !");

			if (bKeepContent && m_p == m_bufOnStack)
				memcpy(m_bufOnHeap, m_bufOnStack, m_length);

			m_p = m_bufOnHeap;
			m_length = nNewSize;
		}

		if (!bKeepContent && bZeroMemory)
			memset(m_p, 0, nNewSize);

		return m_p;
	}

private:
	void _free()
	{
		m_p = m_bufOnStack;
		m_length = nSizeOnStack;

		if (m_bufOnHeap)
		{
			free(m_bufOnHeap);
			m_bufOnHeap = NULL;
		}
	}

private:
	unsigned int  m_length;						//leng of m_p
	unsigned char m_bufOnStack[nSizeOnStack];	
	void *        m_bufOnHeap;
	void *        m_p;							//p-> stack or heap
};

class StringA2StringW
{
public:
	StringA2StringW(){}
	StringA2StringW(const char* lpszStringA, long nLengthInByte = -1, UINT nCodePage = CP_ACP)
	{
		Convert(lpszStringA, nLengthInByte, nCodePage);
	}
	operator const wchar_t*()
	{
		return (const wchar_t*)m_memW.getBuffer(0);
	}
	void Convert(const char* lpszStringA, long nLengthInByte = -1, UINT nCodePage = CP_ACP)
	{
		if (lpszStringA == NULL || *lpszStringA == 0 || nLengthInByte == 0)
			*(wchar_t*)m_memW.getBuffer(2) = L'/0';
		else
		{
			if (nLengthInByte == -1) nLengthInByte = (long)strlen(lpszStringA);
			int nLengthInWchar = MultiByteToWideChar(nCodePage, 0, lpszStringA, nLengthInByte, NULL, 0);
			wchar_t* pStringW  = (wchar_t*)m_memW.getBuffer(nLengthInWchar * 2 + 2);
			MultiByteToWideChar(nCodePage, 0, lpszStringA, nLengthInByte, pStringW, nLengthInWchar);
			pStringW[nLengthInWchar] = L'/0';
		}
	}
private:
	memAlloc<>  m_memW;
};
class StringW2StringA
{
public:
	StringW2StringA(){}
	StringW2StringA(const wchar_t* lpszStringW, long nLengthInWchar = -1, UINT nCodePage = CP_ACP)
	{
		Convert(lpszStringW, nLengthInWchar, nCodePage);
	}
	operator const char*()
	{
		return (const char*)m_memA.getBuffer(0);
	}
	void Convert(const wchar_t* lpszStringW, long nLengthInWchar = -1, UINT nCodePage = CP_ACP)
	{
		if (lpszStringW == NULL || *lpszStringW == 0 || nLengthInWchar == 0)
			*(char*)m_memA.getBuffer(1) = '/0';
		else
		{
			if (nLengthInWchar == -1) nLengthInWchar = (long)wcslen(lpszStringW);
			int nLengthInByte = WideCharToMultiByte(nCodePage, 0, lpszStringW, nLengthInWchar, NULL, 0, 0, 0);
			char* pStringA = (char*)m_memA.getBuffer(nLengthInByte + 1);
			WideCharToMultiByte(nCodePage, 0, lpszStringW, nLengthInWchar, pStringA, nLengthInByte, 0, 0);
			pStringA[nLengthInByte] = '/0';
		}
	}
private:
	memAlloc<> m_memA;
};
class StringA2StringA
{
public:
	StringA2StringA(){}
	StringA2StringA(UINT nCodePageFrom, UINT nCodePageTo, const char* lpszStringA, long nLengthInByte = -1)
	{
		Convert(nCodePageFrom, nCodePageTo, lpszStringA, nLengthInByte);
	}
	operator const char*()
	{
		return (const char*)m_WtoA;
	}
	void Convert(UINT nCodePageFrom, UINT nCodePageTo, const char* lpszStringA, long nLengthInByte = -1)
	{
		m_AtoW.Convert(lpszStringA, nLengthInByte, nCodePageFrom);
		m_WtoA.Convert((const wchar_t*)m_AtoW, -1, nCodePageTo);
	}
private:
	StringA2StringW m_AtoW;
	StringW2StringA m_WtoA;
};

typedef StringA2StringW AtoW;
typedef StringW2StringA WtoA;
typedef StringA2StringA AtoA;

#ifdef _UNICODE
	#define TtoA WtoA
	#define AtoT AtoW
	#define TtoW
	#define WtoT
#else
	#define TtoA
	#define AtoT
	#define TtoW AtoW
	#define WtoT WtoA
#endif