Search code examples
c++mfcc-stringsstdstring

How do you convert CString and std::string std::wstring to each other?

CString is quite handy, while std::string is more compatible with STL container. I am using hash_map. However, hash_map does not support CStrings as keys, so I want to convert the CString into a std::string.

Writing a CString hash function seems to take a lot of time.

CString -----> std::string

How can I do this?

std::string -----> CString:

inline CString toCString(std::string const& str)
{
    return CString(str.c_str()); 
}

Am I right?

EDIT:

Here are more questions:

How can I convert from wstring to CString and vice versa?

// wstring -> CString
std::wstring src;
CString result(src.c_str());

// CString -> wstring
CString src;
std::wstring des(src.GetString());

Is there any problem with this?

Additionally, how can I convert from std::wstring to std::string and vice versa?

Solution

  • According to CodeGuru:

    CString to std::string:

    CString cs("Hello");
std::string s((LPCTSTR)cs);

    BUT: std::string cannot always construct from a LPCTSTR. i.e. the code will fail for UNICODE builds.

    As std::string can construct only from LPSTR / LPCSTR, a programmer who uses VC++ 7.x or better can utilize conversion classes such as CT2CA as an intermediary.

    CString cs ("Hello");
// Convert a TCHAR string to a LPCSTR
CT2CA pszConvertedAnsiString (cs);
// construct a std::string using the LPCSTR input
std::string strStd (pszConvertedAnsiString);

    std::string to CString: (From Visual Studio's CString FAQs...)

    std::string s("Hello");
CString cs(s.c_str());

    CStringT can construct from both character or wide-character strings. i.e. It can convert from char* (i.e. LPSTR) or from wchar_t* (LPWSTR).

    In other words, char-specialization (of CStringT) i.e. CStringA, wchar_t-specilization CStringW, and TCHAR-specialization CString can be constructed from either char or wide-character, null terminated (null-termination is very important here) string sources.
    Althoug IInspectable amends the "null-termination" part in the comments:

    NUL-termination is not required.
    CStringT has conversion constructors that take an explicit length argument. This also means that you can construct CStringT objects from std::string objects with embedded NUL characters.