MFC编程中各种字符串之间的转换

std::string转为 std::wstring

std::wstring UTF8_To_UTF16(const std::string& source)
{
	unsigned long len = ::MultiByteToWideChar(CP_UTF8, NULL, source.c_str(), -1, NULL, NULL);
	if(len == 0)
		return std::wstring();
	wchar_t *buffer = new wchar_t[len];
	::MultiByteToWideChar(CP_UTF8, NULL, source.c_str(), -1, buffer, len);

	std::wstring dest(buffer);
	delete[] buffer;
	return dest;
}

std::wstring转为 std::string

std::string UTF16_To_UTF8(const std::wstring& source)
{
	unsigned long len = ::WideCharToMultiByte(CP_UTF8, NULL, source.c_str(), -1, NULL, NULL, NULL, NULL);
	if(0 == len)
	{
		return std::string();
	}

	char* buffer = new char[len];
	::WideCharToMultiByte(CP_UTF8, NULL, source.c_str(), -1, buffer, len, NULL, NULL);
	std::string dest(buffer);
	delete[] buffer;
	return dest;

}

CString 转为 int

代码块

    CString str = "123";
    _ttoi(str);

CString 转为 string

代码块

    CString str = "123";
    _tsetlocale(LC_ALL, _T(""));
    char szTem[1000];
    wcstombs(szTem, str , 1000);   
    string filename(szTem);

#int转字符串string

代码块

   char t[256];
   string f1;
   sprintf(t, "%d", f);
   f1 = t;

##WString转string

std::string WstringToString(const std::wstring str)
{
	if (str.size() == 0)
	{
		return "";
	}
	unsigned len = str.size() * 4;
    setlocale(LC_CTYPE, "");
    char *p = new char[len];
    wcstombs(p,str.c_str(),len);
    std::string str1(p);
    delete[] p;
    return str1;
}

##const char转为 const wchat_t

代码块

 #include<comdef.h>//_bstr_t
 const char* filename = (LPCWSTR)(_bstr_t)filename;

char * to BSTR

VC6中对BSTR定义如下：

#if defined(WIN32) && !defined(OLE2ANSI)
typedef WCHAR OLECHAR;
#else
typedef char OLECHAR;
#endif
typedef OLECHAR* BSTR;

在MSDN中的Allocating and Releasing Memory for a BSTR一文中，强调了在使用这个类型时，要在内存上小心对待，以避免发生内存泄露。对于从函数中传出的BSTR，接受的对象要负责对这个BSTR的内存进行管理

UINT const CodePage = CP_ACP;
wchar_t*		m_wstr;
//Convert char * to BSTR 
	/*  Params:
	 *  pSrc			源字符串    		[in] 
	 *  CodePage		代码页	            [in] default value is CP_ACP:系统默认的代码页
	 *
	 *  Return Values:
	 *  BSTR				
	 *  
	 *  Notes: 在对象析构时为返回值BSTR分配的内存会被释放掉,另外同一个对象第二次调用该方法时,上一次返回的BSTR分配的内容会被释放掉
	 * 所以调用者每次调用该方法时，需要小心，以免出现野指针。这样做的目的是不需要调用者释放内容，以免调用者忘记 造成内存泄露 。
	 */
	inline BSTR ConvertStringToBSTR(const char* pSrc, UINT CodePage=CodePage)
	{
		if(!pSrc) return NULL;
		
		if (m_wstr != NULL) 
		{
			::SysFreeString(m_wstr);
			m_wstr = NULL;
		}
		
		DWORD cwch;		

		if(cwch = ::MultiByteToWideChar(CodePage, 0, pSrc, -1, NULL, 0))//get size minus NULL terminator
		{
			cwch--;
			m_wstr = ::SysAllocStringLen(NULL, cwch);
			
			if(m_wstr)
			{
				if(!::MultiByteToWideChar(CodePage, 0, pSrc, -1, m_wstr, cwch))
				{
					if(ERROR_INSUFFICIENT_BUFFER == ::GetLastError())
						return m_wstr;
					::SysFreeString(m_wstr);//must clean up
					m_wstr = NULL;
				}
			}			
		}
		
		return m_wstr;
	};

BSTR to char *

char*			m_str;
UINT const CodePage = CP_ACP;
//Convert BSTR to char *  
	/*  Params:
	 *  pSrc				源字符串    		[in] 
	 *  CodePage			代码页	            [in] default value is CP_ACP:系统默认的代码页
	 *
	 *  Return Values:
	 *  char*				
	 *  
	 *  Notes: 在对象析构时为返回值char*分配的内存会被释放掉,另外同一个对象第二次调用该方法时,上一次返回的char*分配的内容会被释放掉
	 *         所以调用者每次调用该方法时，需要小心，以免出现野指针。这样做的目的是不需要调用者释放内容，以免调用者忘记 造成内存泄露 。
	 */
	inline char* ConvertBSTRToString(BSTR pSrc, UINT CodePage=CodePage)
	{			
		if(!pSrc) return NULL;

		if(m_str != NULL)
		{
			delete [] m_str;
			m_str = NULL;
		}
		
		DWORD cb, cwch = ::SysStringLen(pSrc);//convert even embeded NULL		
		
		if(cb = ::WideCharToMultiByte(CodePage, 0, pSrc, cwch + 1, NULL, 0, 0, 0))
		{
			m_str = new char[cb];
			if(m_str)
			{
				m_str[cb - 1]  = '\0';
				
				if(!::WideCharToMultiByte(CodePage, 0, pSrc, cwch + 1, m_str, cb, 0, 0))
				{
					delete []m_str;//clean up if failed;
					m_str = NULL;
				}
			}
		}

		return m_str;
	};

char * to wchar*

UINT const CodePage = CP_ACP;
WCHAR *			m_pWChar;
//Convert char * to wchar* 
	/*  Params:
	 *  pSrc				源字符串    		[in] 
	 *  CodePage			代码页	            [in] default value is CP_ACP:系统默认的代码页
	 *
	 *  Return Values:
	 *  BSTR				
	 *  
	 *  Notes: 在对象析构时为返回值BSTR分配的内存会被释放掉,另外同一个对象第二次调用该方法时,上一次返回的BSTR分配的内容会被释放掉
	 *         所以调用者每次调用该方法时，需要小心，以免出现野指针。这样做的目的是不需要调用者释放内容，以免调用者忘记 造成内存泄露 。
	 */
	inline WCHAR* ACH2WCH(const char* pSrc, UINT CodePage=CodePage)
	{
		if(!pSrc) return NULL;
		
		if (m_pWChar != NULL) 
		{
			delete [] m_pWChar;
			m_pWChar = NULL;
		}

		//Use api convert routine
		int nLen = MultiByteToWideChar( CodePage,
										0,
										pSrc,
										-1,
										NULL,
										0);

		//if wlen == 0, some unknown codepage was probably used.		
		if(nLen == 0)
		{
			return NULL;
		}

		m_pWChar = new WCHAR[nLen+2];

		MultiByteToWideChar(CodePage,
							0,
							pSrc,
							-1,
							m_pWChar,
							nLen);
		m_pWChar[nLen] = _T('\0');
		
		return m_pWChar;
	};

wchar * to char *

char* m_pChar;

//Convert wchar * to char *  
	/*  Params:
	 *  pSrc				源字符串    		[in] 
	 *  CodePage			代码页	            [in] default value is CP_ACP:系统默认的代码页
	 *
	 *  Return Values:
	 *  char*				
	 *  
	 *  Notes: 在对象析构时为返回值char*分配的内存会被释放掉,另外同一个对象第二次调用该方法时,上一次返回的char*分配的内容会被释放掉
	 *         所以调用者每次调用该方法时，需要小心，以免出现野指针。这样做的目的是不需要调用者释放内容，以免调用者忘记 造成内存泄露 。
	 */
	inline char* WCH2ACH(const WCHAR *pSrc, UINT CodePage=CodePage)
	{			
		if(!pSrc) return NULL;
		
		if(m_pChar != NULL)
		{
			delete [] m_pChar;
			m_pChar = NULL;
		}

		int nlen = 	WideCharToMultiByte(CodePage,
								0,
								pSrc,
								-1, 
								NULL,
								0,
								NULL,
								NULL);

		//if alen == 0, some unknown codepage was probably used.
		if(nlen == 0) 
		{
			return NULL;
		}

		//Use mfc convert routine
		m_pChar = new char[nlen+2]; 		

		WideCharToMultiByte(CodePage,
							0,
							pSrc,
							-1,
							m_pChar,
							nlen, 
							NULL,
							NULL
							);	
		m_pChar[nlen] = '\0';
		return m_pChar;
	};