Comment faire pour convertir un TCHAR tableau à std::string?

Comment puis-je convertir un TCHAR tableau de std::string (ne pas std::basic_string)?

Vous vous rendez compte std::string est juste un typedef pour un std::basic_string<char>?
Et voulez-vous convertir un spécifiquement Unicode ou MBCS TCHAR (c'est à dire vraiment WCHAR ou CHAR) dans un std::string (c'est à dire char) toujours, ou les convertir en CHAR à la chaîne et WCHAR à wstring, ou quelque chose d'autre?

InformationsquelleAutor ashmish2 | 2011-06-09

34

TCHAR est juste une définition de type qui, en fonction de votre configuration de la compilation, soit par défaut char ou wchar.

Bibliothèque de modèles Standard prend en charge les deux ASCII (avec std::string) et les jeux de caractères (avec std::wstring). Tout ce que vous devez faire est de typedef Chaîne std::string ou std::wstring en fonction de votre configuration de la compilation. Pour maintenir la souplesse, vous pouvez utiliser le code suivant:
```
#ifndef UNICODE  
  typedef std::string String; 
#else
  typedef std::wstring String; 
#endif
```
Vous pouvez maintenant utiliser String dans votre code et de laisser le compilateur gérer le méchant pièces. La chaîne aura maintenant les constructeurs qui vous permet de convertir TCHAR à std::string ou std::wstring.
- le problème est que je dois appeler une interface qui accepte std::string donc je ne peux pas envoyer std::wstring 🙁
- Voir cette question pour savoir comment convertir wstring à la chaîne.
- Comment String travailler avec cout en Unicode environnement?
- La même chose Alok Enregistrer l'a fait avec std::string et std::wstring vous aimerais aussi avoir à faire avec std::cout et std::wcout.
- donc typedef std::wcout std_tcout et std_tstring etc? Je ne peux pas... me mettre à la façade d'un standard du genre. Puis de nouveau, j'ai l'habitude de le faire pour les opérations graphiques de tous les temps. Pourquoi ne pas std::basic_string<TCHAR> pour la première moitié de la définition de type de chaîne est-il une différence visible?
- href="http://stackoverflow.com/questions/2573834/c-convert-string-or-char-to-wstring-or-wchar-t" title="c convertit une chaîne ou char à wstring ou wchar t">stackoverflow.com/questions/2573834/... montre que la conversion entre std::wstring et std::string, en supposant que l'UTF-8, mais il y a d'autres scénarios. Considérant que c'est VS, je voudrais simplement essayer de s'en tenir à W2A() et A2W() dans la plupart des cas cependant.
InformationsquelleAutor Alok Save

TCHAR type est char ou wchar_t, selon les paramètres de votre projet.

 #ifdef UNICODE
     //TCHAR type is wchar_t
 #else
     //TCHAR type is char
 #endif

Donc, si vous devez utiliser std::string au lieu de std::wstring, vous devez utiliser un convertisseur de fonction. Je peut utiliser wcstombs ou WideCharToMultiByte.

TCHAR * text;

#ifdef UNICODE
    /*/
    //Simple C
    const size_t size = ( wcslen(text) + 1 ) * sizeof(wchar_t);
    wcstombs(&buffer[0], text, size);
    std::vector<char> buffer(size);
    /*/
    //Windows API (I would use this)
    std::vector<char> buffer;
    int size = WideCharToMultiByte(CP_UTF8, 0, text, -1, NULL, 0, NULL, NULL);
    if (size > 0) {
        buffer.resize(size);
        WideCharToMultiByte(CP_UTF8, 0, text, -1, static_cast<BYTE*>(&buffer[0]), buffer.size(), NULL, NULL);
    }
    else {
        //Error handling
    }
    //*/
    std::string string(&buffer[0]);
#else
    std::string string(text);
#endif

Je l'ai essayé, eu: error C2664: 'std::basic_string<_Elem,_Traits,_Ax>::basic_string(const std::basic_string<_Elem,_Traits,_Ax> &)' : impossible de convertir le paramètre 1 de 'TCHAR [50]' à 'const std::basic_string<_Elem,_Traits,_Ax> &"
Je l'ai juste essayé de VS2012. Code: lien.

InformationsquelleAutor Naszta

4

TCHAR est soit char ou wchar_t, donc un
```
typedef basic_string<TCHAR>   tstring;
```
est une façon de le faire.

L'autre est de passer char complètement et il suffit d'utiliser std::wstring.

InformationsquelleAutor Bo Persson
3

Ma réponse est tardive, je vous l'avoue, mais avec les réponses de "Alok Enregistrer" et quelques recherches j'ai trouvé un bon moyen! (Note: je n'ai pas tester cette version, beaucoup, de sorte qu'il peut ne pas fonctionner dans tous les cas, mais de ce que j'ai testé il devrait):
```
TCHAR t = SomeFunctionReturningTCHAR();
std::string str;

#ifndef UNICODE
    str = t;
#else
    std::wstring wStr = t;
    str = std::string(wStr.begin(), wStr.end());
#endif

std::cout << str << std::endl; //<-- should work!
```
- Il ne fonctionne que pour 7 bits ASCII, mais les tirages des ordures pour les autres personnages.
InformationsquelleAutor Aemmel

-1

Simple!

char* tcharToChar(TCHAR* buffer)
{
    char *charBuffer = NULL;
    int lengthOfbuffer = lstrlenW(buffer);
    if(buffer!=NULL)
    {
        charBuffer = (char*)calloc(lengthOfbuffer+1,sizeof(char));
    }
    else
    {
        return NULL;
    }

    for (int index = 0;
        index < lengthOfbuffer;
        index++)
    {
        char *singleCharacter = (char*)calloc(2,sizeof(char));
        singleCharacter[0] = (char)buffer[index];
        singleCharacter[1] = 'char* tcharToChar(TCHAR* buffer)
{
char *charBuffer = NULL;
int lengthOfbuffer = lstrlenW(buffer);
if(buffer!=NULL)
{
charBuffer = (char*)calloc(lengthOfbuffer+1,sizeof(char));
}
else
{
return NULL;
}
for (int index = 0;
index < lengthOfbuffer;
index++)
{
char *singleCharacter = (char*)calloc(2,sizeof(char));
singleCharacter[0] = (char)buffer[index];
singleCharacter[1] = '\0';
strcat(charBuffer, singleCharacter);
}
strcat(charBuffer, "\0");
return charBuffer;
}
';
        strcat(charBuffer, singleCharacter);
    }
    strcat(charBuffer, "char* tcharToChar(TCHAR* buffer)
{
char *charBuffer = NULL;
int lengthOfbuffer = lstrlenW(buffer);
if(buffer!=NULL)
{
charBuffer = (char*)calloc(lengthOfbuffer+1,sizeof(char));
}
else
{
return NULL;
}
for (int index = 0;
index < lengthOfbuffer;
index++)
{
char *singleCharacter = (char*)calloc(2,sizeof(char));
singleCharacter[0] = (char)buffer[index];
singleCharacter[1] = '\0';
strcat(charBuffer, singleCharacter);
}
strcat(charBuffer, "\0");
return charBuffer;
}
");
    return charBuffer;

}

Puis capturer le char * en std::string

Maintenant, vous devez posséder un pointeur brut vous avez besoin pour nettoyer. Pourquoi pas le retour d'un std::string à la place? Edit : Vous avez également la fuite d'une tonne de petits tampons avec singleCharacter. Cette solution n'est pas acceptable en l'état. Il n'est pas nécessaire d'allouer dynamiquement pour singleCharacter et je ne vois pas la nécessité pour strcat pour écrire une chaîne de caractère par caractère.

InformationsquelleAutor user1567759

Vous devez vous connecter pour publier un commentaire.