Comment convertir CString et ::std::string ::std::wstring les uns les autres?

Selon CodeGuru:

CString à std::string:

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

MAIS: std::string ne peut pas toujours construire à partir d'un LPCTSTR. c'est à dire le code suivant ne fonctionnera pas pour les générations de UNICODE.

Comme std::string peut construire que de LPSTR /LPCSTR, un programmeur qui utilise VC++ 7.x ou mieux peut utiliser la conversion des classes comme CT2CA comme un intermédiaire.

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 à CString: (À partir de Visual Studio CString foire aux questions...)

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

CStringT peut construire à partir de deux caractères ou large-les chaînes de caractères. c'est à dire Il peut convertir de char* (c'est à dire LPSTR) ou de wchar_t* (LPWSTR).

En d'autres termes, char-spécialisation (de CStringT) c'est à dire CStringA, wchar_t-specilization CStringW, et TCHAR-spécialisation CString peuvent être construits à partir soit char ou de grand caractère, null (null-résiliation est très important ici) string sources.

Althoug IInspectable modifie la valeur "null-résiliation" partie dans les commentaires:

NUL de terminaison n'est pas nécessaire.

CStringT a la conversion des constructeurs de prendre explicitement un argument de longueur. Cela signifie également que vous pouvez construire CStringT objets de std::string objets embarqués NUL caractères.

Il est plus efficace pour convertir CString à std::string à l'aide de la conversion où la longueur est spécifiée.

CString someStr("Hello how are you");
std::string std(somStr, someStr.GetLength());

En boucle serrée, cela permet une amélioration significative de la performance.

(Depuis VS2012 ...et au moins jusqu'à VS2017 v15.8.1)

Puisque c'est un projet MFC & CString est une classe MFC, MS fournit une Note Technique TN059: à l'Aide de MFC MBCS de Conversion Unicode/Macros et Générique de Macros de Conversion:

A2CW      (LPCSTR)  -> (LPCWSTR)  
A2W       (LPCSTR)  -> (LPWSTR)  
W2CA      (LPCWSTR) -> (LPCSTR)  
W2A       (LPCWSTR) -> (LPSTR)  

Utilisation:

void Example() //** UNICODE case **
{
    USES_CONVERSION; //(1)

    //CString to std::string /std::wstring
    CString strMfc{ "Test" }; //strMfc = L"Test"
    std::string strStd = W2A(strMfc); //** Conversion Macro: strStd = "Test" **
    std::wstring wstrStd = strMfc.GetString(); //wsrStd = L"Test"

    //std::string to CString /std::wstring
    strStd = "Test 2";
    strMfc = strStd.c_str(); //strMfc = L"Test 2"
    wstrStd = A2W(strStd.c_str()); //** Conversion Macro: wstrStd = L"Test 2" **

    //std::wstring to CString /std::string 
    wstrStd = L"Test 3";
    strMfc = wstrStd.c_str(); //strMfc = L"Test 3"
    strStd = W2A(wstrStd.c_str()); //** Conversion Macro: strStd = "Test 3" **
}

--

Notes de bas de page:

(1) afin de pour la conversion des macros pour avoir de l'espace pour stocker la temporaire de longueur, il est nécessaire de déclarer une variable locale appelée _convert qui fait cela dans chaque fonction qui utilise les macros de conversion. Cela se fait en invoquant la USES_CONVERSION macro. Dans VS2017 code MFC (atlconv.h) il ressemble à ceci:

#ifndef _DEBUG
    #define USES_CONVERSION int _convert; (_convert); UINT _acp = ATL::_AtlGetConversionACP() /*CP_THREAD_ACP*/; (_acp); LPCWSTR _lpw; (_lpw); LPCSTR _lpa; (_lpa)
#else
    #define USES_CONVERSION int _convert = 0; (_convert); UINT _acp = ATL::_AtlGetConversionACP() /*CP_THREAD_ACP*/; (_acp); LPCWSTR _lpw = NULL; (_lpw); LPCSTR _lpa = NULL; (_lpa)
#endif

Cela fonctionne bien:

//Convert CString to std::string
inline std::string to_string(const CString& cst)
{
    return CT2A(cst.GetString());
}

Fonctionne pour moi:

std::wstring CStringToWString(const CString& s)
{
    std::string s2;
    s2 = std::string((LPCTSTR)s);
    return std::wstring(s2.begin(),s2.end());
}

CString WStringToCString(std::wstring s)
{
    std::string s2;
    s2 = std::string(s.begin(),s.end());
    return s2.c_str();
}

Est-il tout problème?

Il y a plusieurs problèmes:

• CString est un modèle de la spécialisation de CStringT. Selon le BaseType décrivant le type de caractères, il y a deux spécialisations: CStringA (à l'aide de char) et CStringW (à l'aide de wchar_t).
• Tout wchar_t sur Windows est ubiquitaire utilisé pour stocker codé en UTF-16 unités de code, à l'aide de char est ambigu. Le dernier couramment magasins ANSI caractères codés, mais peut également stocker des caractères ASCII, UTF-8, ou même des données binaires.
• Nous ne savons pas l'encodage des caractères (ou le même type de caractère) de CString (qui est contrôlé par la _UNICODE symbole de préprocesseur), faisant de la question de l'ambiguïté. Nous ne savons pas non plus que le caractère souhaité encodage de std::string.
• La conversion entre Unicode et ANSI est intrinsèquement avec perte: codage ANSI ne peut représenter un sous-ensemble du jeu de caractères Unicode.

Pour répondre à ces questions, je vais supposer que wchar_t va stocker codé en UTF-16 unités de code, et char tiendra UTF-8 octet séquences. C'est le seul choix raisonnable que vous pouvez faire pour s'assurer que la source et la destination des chaînes de conserver la même information, sans préjudice de la solution à un sous-ensemble de la source ou de la destination domaines.

Les implémentations suivantes convertir entre CStringA/CStringW et std::wstring/std::string cartographie de l'UTF-8, UTF-16 et vice versa:

#include <string>
#include <atlconv.h>

std::string to_utf8(CStringW const& src_utf16)
{
    return { CW2A(src_utf16.GetString(), CP_UTF8).m_psz };
}

std::wstring to_utf16(CStringA const& src_utf8)
{
    return { CA2W(src_utf8.GetString(), CP_UTF8).m_psz };
}

Les deux autres fonctions de construire la chaîne C++ objets de la sfm, cordes, laissant le codage inchangé. Notez que, bien que les fonctions précédentes ne peuvent pas faire face avec embedded NUL, les personnages, ces fonctions sont à l'abri de cela.

#include <string>
#include <atlconv.h>

std::string to_std_string(CStringA const& src)
{
    return { src.GetString(), src.GetString() + src.GetLength() };
}

std::wstring to_std_wstring(CStringW const& src)
{
    return { src.GetString(), src.GetString() + src.GetLength() };
}

Si vous êtes à la recherche pour convertir facilement entre les autres types de chaînes, peut-être le _bstr_t classe serait plus approprié? Il prend en charge converstion entre char, wchar_t et BSTR.