Как прочитать значение из реестра 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

пара RegOpenKey и RegQueryKeyEx будет делать трюк.

Если вы используете MFC CRegKey классе-это еще более простое решение.

RegQueryValueEx

Это дает значение, если оно существует, и возвращает код ошибки ERROR_FILE_NOT_FOUND, если ключ не существует.

(Я не могу сказать, работает ли моя ссылка или нет, но если вы просто google для "RegQueryValueEx" первый хит-это документация msdn.)

Начиная С Windows >=Vista / Server 2008,RegGetValue, который это более безопасная функция чем RegQueryValueEx. Нет необходимости RegOpenKeyEx,RegCloseKey или NUL проверка завершения строковых значений (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;
}

параметр dwFlags поддерживает флаги для ограничения типа, заполняя буфер значений нулями при сбое (RRF_ZEROONFAILURE) и 32 / 64bit доступ к реестру (RRF_SUBKEY_WOW6464KEY, RRF_SUBKEY_WOW6432KEY) для 64-разрядных программ.

    #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;
    }