Convertir const char* wstring

Je suis en train de travailler sur une extension native pour une base de zinc application flash et j'ai besoin de convertir un const char* à un wstring.

C'est mon code:

mdmVariant_t* appendHexDataToFile(const zinc4CallInfo_t *pCallInfo, int paramCount, mdmVariant_t **params) {

    if(paramCount >= 2) {
        const char *file    = mdmVariantGetString(params[0]);
        const char *data    = mdmVariantGetString(params[1]);

        return mdmVariantNewInt(native.AppendHexDataToFile(file, data));
    }
    else {
        return mdmVariantNewBoolean(FALSE);
    }
}

Mais native.AppendHexDataToFile() besoin de deux wstring.
Je ne suis pas très bon avec le C++ et je pense que tous les différents types de chaînes sont totalement confus et je n'ai pas trouvé quelque chose d'utile dans le filet. Donc je vous demande comment les gars pour le faire.

Modifier: Les Chaînes de caractères UTF-8 et je suis sur OSX et Windows XP/Vista/7

Avant d'essayer de traiter avec les caractères et les caractères de large, vous devriez être en mesure de répondre à la question suivante: Comment êtes-vous des chaînes codées et quelle conversion comptez-vous faire ?
En plus de @ereOn qui plattform utilisez-vous?

OriginalL'auteur Johannes Klauß | 2012-05-24

  1. 15

    Je vous recommandons d'utiliser std::string au lieu de C-style cordes (char*) dans la mesure du possible. Vous pouvez créer std::string objet de const char* par simple passage à son constructeur.

    Une fois que vous avez std::string, vous pouvez créer une fonction simple qui vous permet de convertir std::string contenant multi-octets caractères UTF-8 std::wstring contenant codé en UTF-16 points (16 bits représentation des caractères spéciaux à partir de std::string).

    Il y a plus de façons de le faire, voici le chemin en utilisant MultiByteToWideChar fonction:

    std::wstring s2ws(const std::string& str)
{
    int size_needed = MultiByteToWideChar(CP_UTF8, 0, &str[0], (int)str.size(), NULL, 0);
    std::wstring wstrTo( size_needed, 0 );
    MultiByteToWideChar(CP_UTF8, 0, &str[0], (int)str.size(), &wstrTo[0], size_needed);
    return wstrTo;
}

    Vérifier ces questions:

    La cartographie multi-octets caractères unicode point de la représentation

    Pourquoi utiliser MultiByteToWideCharArray pour convertir std::string à std::wstring?

    Avertissement: MultiByteToWideChar est un Windows uniquement fonction. (OP est à l'aide de Windows, mais la question est marqué juste c++)
    Il serait mieux si votre solution est multi-plateforme.
    C'est encore la meilleure conversion sur Windows. MS dit ici, ", Votre application peut convertir entre Windows les pages de code et de code OEM pages à l'aide de la norme C fonctions de la bibliothèque runtime. Cependant, l'utilisation de ces fonctions présente un risque de perte de données, car les caractères qui peuvent être représentés par chaque page de code ne correspondent pas exactement" Cependant, je me demande si on devrait utiliser les CP_ACP page de codes lors de la conversion de chaînes de caractères obtenus par WINAPI ...UN() des fonctions (par exemple, à partir de GetWindowTextA)

    OriginalL'auteur

  2. 10

    Autant que je sache, cela ne fonctionne qu'à partir de C++11 et ci-dessus:

    #include <codecvt>

//...

std::wstring stringToWstring(const std::string& t_str)
{
    //setup converter
    typedef std::codecvt_utf8<wchar_t> convert_type;
    std::wstring_convert<convert_type, wchar_t> converter;

    //use converter (.to_bytes: wstr->str, .from_bytes: str->wstr)
    return converter.from_bytes(t_str);
}

    Référence de réponse

    Cela doit être accepté de répondre. Je vous remercie.

    OriginalL'auteur

  3. 4

    Vous pouvez convertir char chaîne de wstring directement en tant que code suivant:

    char buf1[] = "12345678901234567890";
wstring ws(&buf1[0], &buf1[20]);

    OriginalL'auteur

  4. 2

    Vous avez besoin d'une bibliothèque qui peut encoder/décoder UTF8. Malheureusement, cette fonctionnalité n'est pas incluse avec le std c++ de la bibliothèque. Voici une bibliothèque, vous pouvez utiliser: http://utfcpp.sourceforge.net/

    Voici un exemple d'utilisation de celui-ci:

    utf8::utf8to32(bytes.begin(), bytes.end(), std::back_inserter(wstr));

    OriginalL'auteur

  5. 1

    Un ajout à la réponse de @anhoppe. Voici comment faire pour convertir char*:

    #include <codecvt>

//...

std::wstring stringToWstring(const char* utf8Bytes)
{
    //setup converter
    using convert_type = std::codecvt_utf8<typename std::wstring::value_type>;
    std::wstring_convert<convert_type, typename std::wstring::value_type> converter;

    //use converter (.to_bytes: wstr->str, .from_bytes: str->wstr)
    return converter.from_bytes(utf8Bytes);
}

    Et voici comment convertir char* si vous aussi vous connaissez déjà la longueur de la mémoire tampon:

    #include <codecvt>

//...

std::wstring stringToWstring(const char* utf8Bytes, const size_t numBytes)
{
    //setup converter
    using convert_type = std::codecvt_utf8<typename std::wstring::value_type>;
    std::wstring_convert<convert_type, typename std::wstring::value_type> converter;

    //use converter (.to_bytes: wstr->str, .from_bytes: str->wstr)
    return converter.from_bytes(utf8Bytes, utf8Bytes + numBytes);
}

    OriginalL'auteur

  6. 0

    Sur OS X wstring utilise UTF-32, plutôt que de l'UTF-16. Vous pouvez faire la conversion comme ceci:

    #include <codecvt>
#include <string>

//make facets usable by giving them a public destructor
template <class Facet>
class usable_facet
    : public Facet
{
public:
    template <class ...Args>
        usable_facet(Args&& ...args)
            : Facet(std::forward<Args>(args)...) {}
    ~usable_facet() {}
};

std::wstring s2ws(std::string const &s) {
    std::wstring_convert<
        usable_facet<std::codecvt<char32_t,char,std::mbstate_t>>
        ,char32_t> convert;
    std::u32string utf32 = convert.from_bytes(s);
    static_assert(sizeof(wchar_t)==sizeof(char32_t),"char32_t and wchar_t must have same size");
    return {begin(utf32),end(utf32)};
}

    OriginalL'auteur

  7. -1

    Voici un code que j'ai trouvé;

    std::wstring StringToWString(const std::string& s)
 {
 std::wstring temp(s.length(),L' ');
 std::copy(s.begin(), s.end(), temp.begin());
 return temp; 
 }

    Et voici l'original post sur le forum avec une deuxième solution à l'aide de la fonction windows API MultiByteToWideChar:

    http://forums.codeguru.com/archive/index.php/t-193852.html

    Que faire si std::string passés à cette fonction contient des caractères multi-octets qui doivent être convertis à codé en UTF-16 de large caractères équivalents?
    Pourquoi pas "la"? il sera effacé de toute façon par la fonction de copie. C'est juste l'arbitraire d'un char pour faire de la place pour la chaîne.
    Alors, pourquoi voulez-vous initialiser ces caractères ' ' quand vous savez qu'ils vont être réécrits?
    parce que la fonction de copie ne pas créer une zone tampon. Le tampon doit être créé en premier, ce qui est fait par le constructeur.
    Ah, désolé, je vois maintenant. Je pensais que basic_string a également constructeur qui ne prend que size_type count, tout comme std::vector.

    OriginalL'auteur