convertir std::string const BYTE* pour RegSetValueEx()

J'ai une fonction qui récupère un std::string. Que les appels de fonction

RegSetValueEx

le 5ème paramètre est la valeur de la valeur de registre et s'attend à une variable de type const BYTE*.
Donc, je dois convertir le std::string const BYTE* et aussi donner la longueur de la matrice résultante comme le 6e paramètre.

J'ai trouvé une façon de le faire, mais il se sent moche et je ne comprends pas vraiment ce qui se passe. Ici est une version allégée de cette fonction:

void function(const std::string& newValue)
{
    HKEY keyHandle;
    if(RegOpenKeyEx(HKEY_CLASSES_ROOT, TEXT("some key"),0,KEY_ALL_ACCESS,&keyHandle) == ERROR_SUCCESS)
    {
        std::wstring wNewValue;
        wNewValue.assign(newValue.begin(),newValue.end());

        if (RegSetValueEx(keyHandle, TEXT("some value"), NULL, REG_SZ, (const BYTE*)(LPCTSTR)(wNewValue.c_str()), wNewValue.size()*2)==ERROR_SUCCESS)
        {
            //do something
        }
        RegCloseKey(keyHandle);
    }
}

Comme vous pouvez le voir, j'ai d'abord faire une grande chaîne de caractères (UNICODE est défini), puis d'utiliser un double jeté, et pour la longueur j'ai à faire *2, sinon il sera seulement mis la moitié de la chaîne d'entrée.

Est cette forme de fonte de la normale, la meilleure façon de le faire?

Pourquoi l' * 2, ce serait une meilleure façon?

Depuis que vous avez utilisé un wstring, vous savez que le sous-jacent est de type wchar_t, et c_str() retournera wchar_t*. Donc pas besoin de cast pour LPCTSTR.

OriginalL'auteur Emile Vrijdags | 2009-05-11

  1. 10
    void function(const std::string& newValue)
{
    HKEY keyHandle;
    if(RegOpenKeyEx(HKEY_CLASSES_ROOT, TEXT("some key"),0,KEY_ALL_ACCESS,&keyHandle) == ERROR_SUCCESS)
    {

        if (RegSetValueExA(keyHandle, "some value", NULL, REG_SZ, (const BYTE*)newValue.c_str(), newValue.size() + 1)==ERROR_SUCCESS)
        {
                //do something
        }
        RegCloseKey(keyHandle);
    }
}

    J'ai enlevé la partie où vous convertir votre chaîne à une wstring, au lieu de cela, vous allez utiliser la version ANSI de RegSetValueEx explicitement.

    citation de RegSetValueEx remarques dans MSDN:

    Si dwType est le REG_SZ, REG_MULTI_SZ,
    ou de type REG_EXPAND_SZ et de l'ANSI
    la version de cette fonction est utilisée
    (soit en appelant explicitement
    RegSetValueExA ou en ne définissant pas de
    UNICODE avant, y compris les Windows.h
    fichier), les données pointées par les
    lpData paramètre doit être un ANSI
    chaîne de caractères. La chaîne est
    converti en Unicode avant il est
    stockées dans le registre.

    Également noter que le paramètre cbData devrait inclure la taille de la terminaison null aswell.

    Si vous êtes explicitement à l'aide de la version ANSI, vous ne devriez pas utiliser le TEXTE() macro, qui sera élargi à L"foo" si UNICODE est défini.
    copier coller le dos de tir! supprimé, merci.
    Donc, tant que je n'utilise pas de caractères non-ANSI-je suis juste très bien avec les versions ANSI de winapi fonctions? (ce qui paraît logique, mais je n'avais pas pensé à ça)
    le Win32API des fonctions qui s'attendent texte sont divisés à la norme ANSI (se termine par Un dans le nom de la fonction) et Unicode (qui se termine avec un "W"), la plupart d'entre eux de toute façon. vous pouvez utiliser std::string avec l'Un et std::wstring avec le W de.
    votre exemple n'aurait pas fonctionné si votre entrée a les caractères en dehors de (probablement) ASCII de toute façon puisque vous faisiez un bit à bit d'extension avec wNewValue.assign(newValue.begin(), newValue.end()). Rappelez-vous que wNewValue est une séquence de caractères UNICODE si le bit à bit d'affectation ne fonctionne que si tous les caractères de points dans newValue sont valables points de code UNICODE. En d'autres termes, newValue ne contient que de l'ISO-8859-1 caractères.

    OriginalL'auteur Idan K

  2. 3

    L' * 2 est parce que RegSetValueEx veut connaître le nombre d'octets à écrire und chaque char (wchar_t) dans un wstring est de deux octets. De sorte que le montant de tableau d'octets a deux fois la taille!

    Il est plus portable à l'utilisation", sizeof _TCHAR" insetad de 2. 😀
    Donc, il serait mieux d'écrire wNewValue.size()*sizeof(wchar_t) pour le rendre clair ce qui se passe.

    OriginalL'auteur Dario

  3. 1

    Ne devrait-elle pas être wNewValue.size()*2+2 ? +2 pour le caractère null?
    MSDN dit: La taille de l'information, pointé par le lpData paramètre, en octets. Si les données sont de type REG_SZ, REG_EXPAND_SZ, ou REG_MULTI_SZ, cbData doit inclure la taille du caractère de fin null ou de caractères.

    OriginalL'auteur Oded S

  4. 1

    Vous pouvez également copier la chaîne unicode dans un tableau d'octets:

    LPWSTR pData = L"SampleGrabber";
int dwSize = wcslen(pData)*sizeof(TCHAR);
BYTE slump[256];
memset((void*) slump, 0, 256*sizeof(BYTE));
memcpy((void*) slump, (const void *) pData, dwSize*sizeof(BYTE));

globit = RegSetValueEx(hKey, NULL, 0, REG_SZ, (const BYTE*) slump, dwSize);

    Si vous avez eu le malheur d'être de l'écriture de code pour WINCE 5.0 appareil et il manquait une partie de l'regedit API.

    OriginalL'auteur david