Comment lire une valeur à partir du registre Windows

const CString REG_SW_GROUP_I_WANT = _T("SOFTWARE\My Corporation\My Package\Group I want");
const CString REG_KEY_I_WANT= _T("Key Name");

CRegKey regKey;
DWORD   dwValue = 0;

if(ERROR_SUCCESS != regKey.Open(HKEY_LOCAL_MACHINE, REG_SW_GROUP_I_WANT))
{
  m_pobLogger->LogError(_T("CRegKey::Open failed in Method"));
  regKey.Close();
  goto Function_Exit;
}
if( ERROR_SUCCESS != regKey.QueryValue( dwValue, REG_KEY_I_WANT))
{
  m_pobLogger->LogError(_T("CRegKey::QueryValue Failed in Method"));
  regKey.Close();
  goto Function_Exit;
}

// dwValue has the stuff now - use for further processing

La paire RegOpenKey et RegQueryKeyEx fera l'affaire.

si vous utilisez MFC CRegKey classe est encore plus facile solution.

RegQueryValueEx

donne la valeur si elle existe, et renvoie un code D'erreur ERROR_FILE_NOT_FOUND si la clé n'existe pas.

(Je ne peux pas dire si mon lien fonctionne ou pas, mais si vous cherchez simplement" RegQueryValueEx " sur google, le premier résultat est la documentation msdn.)

depuis Windows >=Vista / Server 2008, RegGetValue est disponible, qui est une fonction plus sûre que RegQueryValueEx . Pas besoin de RegOpenKeyEx , RegCloseKey ou NUL contrôles de terminaison des valeurs de chaîne ( REG_SZ , REG_MULTI_SZ , REG_EXPAND_SZ ).

#include <iostream>
#include <string>
#include <exception>
#include <windows.h>

/*! \brief                          Returns a value from HKLM as string.
    \exception  std::runtime_error  Replace with your error handling.
*/
std::wstring GetStringValueFromHKLM(const std::wstring& regSubKey, const std::wstring& regValue)
{
    size_t bufferSize = 0xFFF; // If too small, will be resized down below.
    std::wstring valueBuf; // Contiguous buffer since C++11.
    valueBuf.resize(bufferSize);
    auto cbData = static_cast<DWORD>(bufferSize);
    auto rc = RegGetValueW(
        HKEY_LOCAL_MACHINE,
        regSubKey.c_str(),
        regValue.c_str(),
        RRF_RT_REG_SZ,
        nullptr,
        static_cast<void*>(&valueBuf.at(0)),
        &cbData
    );
    while (rc == ERROR_MORE_DATA)
    {
        // Get a buffer that is big enough.
        cbData /= sizeof(wchar_t);
        if (cbData > static_cast<DWORD>(bufferSize))
        {
            bufferSize = static_cast<size_t>(cbData);
        }
        else
        {
            bufferSize *= 2;
            cbData = static_cast<DWORD>(bufferSize);
        }
        valueBuf.resize(bufferSize);
        rc = RegGetValueW(
            HKEY_LOCAL_MACHINE,
            regSubKey.c_str(),
            regValue.c_str(),
            RRF_RT_REG_SZ,
            nullptr,
            static_cast<void*>(&valueBuf.at(0)),
            &cbData
        );
    }
    if (rc == ERROR_SUCCESS)
    {
        valueBuf.resize(static_cast<size_t>(cbData / sizeof(wchar_t)));
        return valueBuf;
    }
    else
    {
        throw std::runtime_error("Windows system error code: " + std::to_string(rc));
    }
}

int main()
{
    std::wstring regSubKey;
#ifdef _WIN64 // Manually switching between 32bit/64bit for the example. Use dwFlags instead.
    regSubKey = L"SOFTWARE\WOW6432Node\Company Name\Application Name\";
#else
    regSubKey = L"SOFTWARE\Company Name\Application Name\";
#endif
    std::wstring regValue(L"MyValue");
    std::wstring valueFromRegistry;
    try
    {
        valueFromRegistry = GetStringValueFromHKLM(regSubKey, regValue);
    }
    catch (std::exception& e)
    {
        std::cerr << e.what();
    }
    std::wcout << valueFromRegistry;
}

son paramètre dwFlags supporte les indicateurs de restriction de type, en remplissant le tampon de valeur avec zéros en cas de panne ( RRF_ZEROONFAILURE ) et accès au registre 32/64bit ( RRF_SUBKEY_WOW6464KEY , RRF_SUBKEY_WOW6432KEY ) pour les programmes 64bit.

    #include <windows.h>
    #include <map>
    #include <string>
    #include <stdio.h>
    #include <string.h>
    #include <tr1/stdint.h>
    using namespace std;
   void printerr(DWORD dwerror) {
        LPVOID lpMsgBuf;
        FormatMessage(
            FORMAT_MESSAGE_ALLOCATE_BUFFER |
            FORMAT_MESSAGE_FROM_SYSTEM |
            FORMAT_MESSAGE_IGNORE_INSERTS,
            NULL,
            dwerror,
            MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
            (LPTSTR) &lpMsgBuf,
            0,
            NULL
        );
        // Process any inserts in lpMsgBuf.
        // ...
        // Display the string.
        if (isOut) {
            fprintf(fout, "%s\n", lpMsgBuf);
        } else {
            printf("%s\n", lpMsgBuf);
        }
        // Free the buffer.
        LocalFree(lpMsgBuf);
    }



    bool regreadSZ(string& hkey, string& subkey, string& value, string& returnvalue, string& regValueType) {
        char s[128000];
        map<string,HKEY> keys;
        keys["HKEY_CLASSES_ROOT"]=HKEY_CLASSES_ROOT;
        keys["HKEY_CURRENT_CONFIG"]=HKEY_CURRENT_CONFIG; //DID NOT SURVIVE?
        keys["HKEY_CURRENT_USER"]=HKEY_CURRENT_USER;
        keys["HKEY_LOCAL_MACHINE"]=HKEY_LOCAL_MACHINE;
        keys["HKEY_USERS"]=HKEY_USERS;
        HKEY mykey;

        map<string,DWORD> valuetypes;
        valuetypes["REG_SZ"]=REG_SZ;
        valuetypes["REG_EXPAND_SZ"]=REG_EXPAND_SZ;
        valuetypes["REG_MULTI_SZ"]=REG_MULTI_SZ; //probably can't use this.

        LONG retval=RegOpenKeyEx(
            keys[hkey],         // handle to open key
            subkey.c_str(),  // subkey name
            0,   // reserved
            KEY_READ, // security access mask
            &mykey    // handle to open key
        );
        if (ERROR_SUCCESS != retval) {printerr(retval); return false;}
        DWORD slen=128000;
        DWORD valuetype = valuetypes[regValueType];
        retval=RegQueryValueEx(
          mykey,            // handle to key
          value.c_str(),  // value name
          NULL,   // reserved
          (LPDWORD) &valuetype,       // type buffer
          (LPBYTE)s,        // data buffer
          (LPDWORD) &slen      // size of data buffer
        );
        switch(retval) {
            case ERROR_SUCCESS:
                //if (isOut) {
                //    fprintf(fout,"RegQueryValueEx():ERROR_SUCCESS:succeeded.\n");
                //} else {
                //    printf("RegQueryValueEx():ERROR_SUCCESS:succeeded.\n");
                //}
                break;
            case ERROR_MORE_DATA:
                //what do I do now?  data buffer is too small.
                if (isOut) {
                    fprintf(fout,"RegQueryValueEx():ERROR_MORE_DATA: need bigger buffer.\n");
                } else {
                    printf("RegQueryValueEx():ERROR_MORE_DATA: need bigger buffer.\n");
                }
                return false;
            case ERROR_FILE_NOT_FOUND:
                if (isOut) {
                    fprintf(fout,"RegQueryValueEx():ERROR_FILE_NOT_FOUND: registry value does not exist.\n");
                } else {
                    printf("RegQueryValueEx():ERROR_FILE_NOT_FOUND: registry value does not exist.\n");
                }
                return false;
            default:
                if (isOut) {
                    fprintf(fout,"RegQueryValueEx():unknown error type 0x%lx.\n", retval);
                } else {
                    printf("RegQueryValueEx():unknown error type 0x%lx.\n", retval);
                }
                return false;

        }
        retval=RegCloseKey(mykey);
        if (ERROR_SUCCESS != retval) {printerr(retval); return false;}

        returnvalue = s;
        return true;
    }