Comment convertir CString et :: std :: string :: std :: wstring l'un vers l'autre?

Question

CString est très pratique, tout en std::string est plus compatible avec les conteneur STL. Je suis l'aide d' hash_map. Toutefois, hash_map ne prend pas en charge CString sous forme de clé, donc je veux convertir CString en std::string.

L'écriture d'un CString fonction de hachage semble prendre beaucoup de temps.

CString -----> std::string

Comment puis-je faire cela?

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

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

Suis-je le droit?

---

EDIT:

Voici d'autres questions:

Comment puis-je convertir wstring, CString les uns les autres?

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

Est-il aucun problème?

Comment puis-je convertir std::wstring, std::string les uns les autres?

Answer 1

Selon CodeGuru:

CString de 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.

En tant que std::string peut construire que d' 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' to 'CString][2]: (À 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 char* (c - LPSTR) ou à partir d' wchar_t* (LPWSTR).

En d'autres termes, char-spécialisation ( CStringTd. CStringA, wchar_t-specilization CStringW, et TCHAR-la spécialisation de l' CString peuvent être construits à partir soit char ou à caractère large, une valeur null (null-résiliation est très important ici) chaîne de sources.
Althoug IInspectable modifie la valeur "null-résiliation de la partie" dans les commentaires:

NUL-la résiliation 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 des objets à partir d' std::string objets embarqués NUL caractères.

Answer 2

Résolvez-le en utilisant std::basic_string<TCHAR> au lieu de std::string et tout devrait bien se passer, quel que soit le paramètre de votre personnage.

Answer 3

Si vous voulez quelque chose de plus C ++, c'est ce que j'utilise. Bien que cela dépende de Boost, ce n'est que des exceptions. Vous pouvez facilement supprimer ceux qui le laissent à dépendre uniquement de la STL et de l’appel WideCharToMultiByte() API Win32.

 #include <string>
#include <vector>
#include <cassert>
#include <exception>

#include <boost/system/system_error.hpp>
#include <boost/integer_traits.hpp>

/**
 * Convert a Windows wide string to a UTF-8 (multi-byte) string.
 */
std::string WideStringToUtf8String(const std::wstring& wide)
{
    if (wide.size() > boost::integer_traits<int>::const_max)
        throw std::length_error(
            "Wide string cannot be more than INT_MAX characters long.");
    if (wide.size() == 0)
        return "";

    // Calculate necessary buffer size
    int len = ::WideCharToMultiByte(
        CP_UTF8, 0, wide.c_str(), static_cast<int>(wide.size()), 
        NULL, 0, NULL, NULL);

    // Perform actual conversion
    if (len > 0)
    {
        std::vector<char> buffer(len);
        len = ::WideCharToMultiByte(
            CP_UTF8, 0, wide.c_str(), static_cast<int>(wide.size()),
            &buffer[0], static_cast<int>(buffer.size()), NULL, NULL);
        if (len > 0)
        {
            assert(len == static_cast<int>(buffer.size()));
            return std::string(&buffer[0], buffer.size());
        }
    }

    throw boost::system::system_error(
        ::GetLastError(), boost::system::system_category);
}
 

Answer 4

Il est plus efficace de convertir CString en std::string utilisant 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 améliore considérablement les performances.

Answer 5

Si vous cherchez à convertir facilement entre d'autres types de chaînes, la classe _bstr_t serait peut-être plus appropriée? Il prend en charge les conversions entre char , wchar_t et BSTR .