la conversion étroite chaîne à grande chaîne

Ce faire, vous devez :

inline std::wstring convert( const std::string& as )
{
            //deal with trivial case of empty string
    if( as.empty() )    return std::wstring();

            //determine required length of new string
    size_t reqLength = ::MultiByteToWideChar( CP_UTF8, 0, as.c_str(), (int)as.length(), 0, 0 );

            //construct new string of required length
    std::wstring ret( reqLength, L'
inline std::wstring convert( const std::string& as )
{
//deal with trivial case of empty string
if( as.empty() )    return std::wstring();
//determine required length of new string
size_t reqLength = ::MultiByteToWideChar( CP_UTF8, 0, as.c_str(), (int)as.length(), 0, 0 );
//construct new string of required length
std::wstring ret( reqLength, L'\0' );
//convert old string to new string
::MultiByteToWideChar( CP_UTF8, 0, as.c_str(), (int)as.length(), &ret[0], (int)ret.length() );
//return new string ( compiler should optimize this away )
return ret;
}
' );

            //convert old string to new string
    ::MultiByteToWideChar( CP_UTF8, 0, as.c_str(), (int)as.length(), &ret[0], (int)ret.length() );

            //return new string ( compiler should optimize this away )
    return ret;
}

Ce qui attend la std::string pour être en UTF-8 (CP_UTF8), lorsque vous avez un autre codage de remplacer la page de codes.

Une autre façon pourrait être :

inline std::wstring convert( const std::string& as )
{
    wchar_t* buf = new wchar_t[as.size() * 2 + 2];
    swprintf( buf, L"%S", as.c_str() );
    std::wstring rval = buf;
    delete[] buf;
    return rval;
}

J'ai trouvé cette pendant googler le problème. J'ai collé le code de référence. Auteur de ce post est Paul McKenzie.

std::string str = "Hello";
std::wstring str2(str.length(), L' '); //Make room for characters

//Copy string to wstring.
std::copy(str.begin(), str.end(), str2.begin());

Voici deux fonctions qui peuvent être utilisées: mbstowcs_s et wcstombs_s.

mbstowcs_s: Convertit une séquence de caractères multioctets une séquence de caractères larges.
wcstombs_s: Convertit une séquence de caractères à une séquence de caractères multioctets.

errno_t wcstombs_s(
   size_t *pReturnValue,
   char *mbstr,
   size_t sizeInBytes,
   const wchar_t *wcstr,
   size_t count 
);

errno_t mbstowcs_s(
   size_t *pReturnValue,
   wchar_t *wcstr,
   size_t sizeInWords,
   const char *mbstr,
   size_t count 

);

Voir http://msdn.microsoft.com/en-us/library/eyktyxsx.aspx et http://msdn.microsoft.com/en-us/library/s7wzt4be.aspx.

La question initiale de ce fil était: "Comment puis-je convertir une étroite chaîne à une grande chaîne?"

Cependant, à partir de l'exemple de code donné dans la question, il semble y avoir aucune conversion n'est nécessaire. Plutôt, il y a une erreur de compilation, en raison de la plus récente compilateurs autodérision quelque chose que l'habitude d'être d'accord. Voici ce que je pense est d'aller sur:

    //wchar_t* wstr = L"A wide string";     //Error: cannot convert from 'const wchar_t *' to 'wchar_t *'

wchar_t const* wstr = L"A wide string";             //okay
const wchar_t* wstr_equivalent = L"A wide string";  //also okay

La c_str() semble être traités de la même manière comme un littéral, et est considéré comme une constante (const). Vous pouvez utiliser un cast. Mais il est préférable d'ajouter des const.

La meilleure réponse que j'ai vu pour la conversion entre les larges et étroites chaînes est d'utiliser std::wstringstream. Et c'est l'une des réponses données à C++ Convertir en chaîne de caractères (ou char*) à wstring (ou wchar_t*)

Vous pouvez convertir presque n'importe quoi et à partir de chaînes de caractères et les chaînes étendues à l'aide de stringstream et wstringstream.

Utilisation mbtowc():

string myName;
wchar_t wstr[BUFFER_SIZE];

getline( cin , myName );
mbtowc(wstr, myName, BUFFER_SIZE);