L'affectation d'un "const char *" à std :: string est autorisée, mais l'affectation à std :: wstring n'est pas compilée. Pourquoi?

Question

J'ai supposé que std :: wstring et std :: string fournissaient plus ou moins la même interface.

J'ai donc essayé de permettre aux capacités unicode pour notre application

# ifdef APP_USE_UNICODE 
    typedef std::wstring AppStringType; 
# else 
    typedef std::string AppStringType; 
# endif 

Cependant cela me donne beaucoup d'erreurs de compilation lors -DAPP_USE_UNICODE est utilisé.

Il s'est avéré que le compilateur étouffe lorsqu'un const char[] est affecté à std::wstring.

EDIT: exemple amélioré en supprimant l'utilisation du littéral "bonjour".

#include <string> 

void myfunc(const char h[]) { 
    string s = h; // compiles OK 
    wstring w = h; // compile Error 
} 

Pourquoi cela fait-il une telle différence?

L'attribution d'un const char* à std::string est autorisée, mais l'affectation à std::wstring génère des erreurs de compilation.

Est-ce que std::wstring ne devrait pas fournir la même interface que std::string? Au moins pour une opération aussi simple que l'affectation?

(environnement: gcc-4.4.1 sur Ubuntu Karmic 32bit)

Answer 1

La partie pertinente de l'API de chaîne est ce constructeur:

basic_string(const charT*); 

Pour std :: string, charT est char. Pour std :: wstring c'est wchar_t. La raison pour laquelle elle ne compile pas est que wstring n'a pas de constructeur char *. Pourquoi wstring n'a-t-il pas de constructeur char *?

Il n'existe pas de méthode unique pour convertir une chaîne de caractère en chaîne de caractères wchar. Quel est le codage utilisé avec la chaîne char? Est-ce juste 7 bits ASCII? Est-ce UTF-8? Est-ce UTF-7? Est-ce SHIFT-JIS? Donc, je ne pense pas qu'il serait tout à fait logique pour std :: wstring d'avoir une conversion automatique de char *, même si vous pouvez couvrir la plupart des cas.Vous pouvez utiliser:

w = std::wstring(h, h + sizeof(h) - 1); 

qui convertira chaque omble chevalier à son tour wchar (à l'exception du terminateur NUL), et dans cet exemple qui est probablement ce que vous voulez. Comme le dit int3, si c'est ce que vous voulez dire, il est préférable d'utiliser un littéral à chaîne large en premier lieu.

Answer 2

Vous devriez faire:

#include <string> 

int main() { 
    const wchar_t h[] = L"hello"; 
    std::wstring w = h; 
    return 0; 
} 

std::string est un typedef de std::basic_string<char>, alors que std::wstring est un typedef de std::basic_string<wchar_t>. En tant que tel, le "équivalent" C-string d'un wstring est un tableau de wchar_t s. Le 'L' devant le littéral de chaîne indique que vous utilisez une constante de chaîne large.

Answer 3

vous devez utiliser

#include <tchar.h> 

TString au lieu de wstring/string TCHAR * au lieu de char * et _T ("bonjour") au lieu de "bonjour" ou L "bonjour"

cette utilisera la forme appropriée de string + char, lorsque _UNICODE est défini.

Answer 4

Petite suggestion ... N'utilisez pas de chaînes "Unicode" sous Linux (par exemple, chaînes étendues). std::string est parfaitement bien et détient très bien Unicode (UTF-8).

La plupart des API Linux fonctionnent avec des chaînes char * et le codage le plus courant est UTF-8.

Alors ... Ne vous embêtez pas avec wstring.

Answer 5

En plus des autres réponses, vous pouvez utiliser un truc du livre de Microsoft (en particulier, tchar.h), et d'écrire quelque chose comme ceci:

# ifdef APP_USE_UNICODE 
    typedef std::wstring AppStringType; 
    #define _T(s) (L##s) 
# else 
    typedef std::string AppStringType; 
    #define _T(s) (s) 
# endif 

AppStringType foo = _T("hello world!"); 

(Note: mon macro-fu est faible, et ce est non testé, mais vous voyez l'idée)

Answer 6

on dirait que vous pouvez faire quelque chose comme ceci:.

#include <sstream> 
    // ... 
    std::wstringstream tmp; 
    tmp << "hello world"; 
    std::wstring our_string = 

Bien que pour une situation plus complexe, vous voudrez peut-BRE abaissez et utilisez mbstowcs

Answer 7

Pour convertir un codage multi-octets en un codage de caractères large, consultez l'en-tête <locale> et le type std::codecvt. La bibliothèque Dinkumware a une classe Dinkum::wstring_convert qui facilite l'exécution de telles conversions multi-octets à larges.

La fonction std::codecvt_byname permet de trouver une instance codecvt pour un codage nommé particulier. Malheureusement, la découverte des noms des codages (ou locales) sur votre système est spécifique à l'implémentation.