C++ 读取REG_SZ 、REG_DWORD 、REG_MULTI_SZ 类型注册表值

1. 读取REG_SZ 类型的注册表键值
   

    // 读取 REG_SZ 类型键值的代码
   
    HKEY  hKey       = NULL;
    DWORD dwSize     = ;
    DWORD dwDataType = ;
    LPBYTE lpValue   = NULL;
    LPCTSTR const lpValueName = _T("TcpPort");
   
    LONG lRet = ::RegOpenKeyEx(HKEY_LOCAL_MACHINE,
       _T("SOFTWARE\\Microsoft\\MSSQLServer\\MSSQLServer\\SuperSocketNetLib\\Tcp"),
       ,
       KEY_QUERY_VALUE,
       &hKey);
    if(ERROR_SUCCESS != lRet)
    {
       // Error handling (see this FAQ)
       // return;
    }
    // Call once RegQueryValueEx to retrieve the necessary buffer size
    ::RegQueryValueEx(hKey,
       lpValueName,
       ,
       &dwDataType,
       lpValue,  // NULL
       &dwSize); // will contain the data size
   
    // Alloc the buffer
    lpValue = (LPBYTE)malloc(dwSize);
   
    // Call twice RegQueryValueEx to get the value
    lRet = ::RegQueryValueEx(hKey,
       lpValueName,
       ,
       &dwDataType,
       lpValue,
       &dwSize);
    ::RegCloseKey(hKey);
    if(ERROR_SUCCESS != lRet)
    {
       // Error handling
       // return;
    }
    // Enjoy of lpValue...
    cout << "port ----------------------- " << lpValue << endl;
   
    // free the buffer when no more necessary
    free(lpValue);
   
    // 此段代码来源：http://forums.codeguru.com/showthread.php?247020-Windows-SDK-Registry-How-can-I-read-data-from-the-registry&s=

2. 读取REG_DWORD 类型的注册表键值
   

    // 读取 REG_DWORD 类型的注册表键值代码
   
    long lRet;
    HKEY hKey;
    DWORD port;
    DWORD dwType = REG_DWORD;
    DWORD dwValue;
    lRet = RegOpenKeyEx(
               HKEY_LOCAL_MACHINE,
               "SOFTWARE\\Microsoft\\MSSQLServer\\Client\\SuperSocketNetLib\\Tcp",
               ,
               KEY_QUERY_VALUE,
               &hKey
           );    //打开注册表
    if(lRet == ERROR_SUCCESS)//读操作成功
    {
        lRet = RegQueryValueEx(
                   hKey,
                   "DefaultPort",
                   ,
                   &dwType,
                   (LPBYTE)&port,
                   &dwValue
               );    //如果打开成功，则读
        if(lRet == ERROR_SUCCESS)
        {
            printf("\n打开成功，则读:");
            cout << "DefaultPort: " << port << endl;
            //mcfile << "DefaultPort: " << port << endl;
            mcfile << "<port>" << port << "</port>" << endl;
        }
        //以下是读取失败
        else
        {
            printf("\n读取失败:");
        }
   
    }
    //以下是打开失败
    else
    {
        printf("\n打开失败:");
    }
    RegCloseKey(hKey);//记住，一定要关闭

3. 读取REG_MULTI_SZ 类型的注册表键值
   

    #include "windows.h"
    #include "tchar.h"
    #include "conio.h"
    #include "stdio.h"
   
    #define MY_KEY _T("PathToMyRegistryKey\\MyRegistryKey") // Registry key
    #define MY_VALUES _T("NameOfTheREG_MULTI_SZListOfValues") // Registry values
    #define NEW_VALUE _T("MyNewValue") // New value
    #define FIND_VALUE _T("AnExistingValue") // We will insert the new value after this one
   
    int _tmain(int argc, _TCHAR* argv[])
    {
        LONG lResult = ;
        HKEY hKey = NULL;
        LPTSTR lpValues = NULL;
        LPTSTR lpValue = NULL;
        LPTSTR lpNewValues = NULL;
        LPTSTR lpNewValue = NULL;
        DWORD cbValues = ;
        DWORD cbNewValues = ;
        DWORD cbNewValue = ;
        BOOL bFound = FALSE;
   
        __try
        {
            // OPEN THE REGISTRY KEY
            //
            _tprintf(_T("RegOpenKeyEx..."));
            lResult = RegOpenKeyEx(
                HKEY_LOCAL_MACHINE,
                MY_KEY,
                ,
                KEY_ALL_ACCESS,
                &hKey
            );
            if (ERROR_SUCCESS != lResult) { _tprintf(_T("ERROR 0x%x\n"), lResult); return ; }
            _tprintf(_T("SUCCESS\n"));
   
            // READ THE REG_MULTI_SZ VALUES
            //
            // Get size of the buffer for the values
            _tprintf(_T("RegQueryValueEx..."));
            lResult = RegQueryValueEx(
                hKey,
                MY_VALUES,
                NULL,
                NULL,
                NULL,
                &cbValues
            );
            if (ERROR_SUCCESS != lResult) { _tprintf(_T("ERROR 0x%x\n"), lResult); return ; }
            _tprintf(_T("SUCCESS\n"));
   
            // Allocate the buffer
            _tprintf(_T("malloc..."));
            lpValues = (LPTSTR)malloc(cbValues);
            if (NULL == lpValues) { _tprintf(_T("ERROR 0x%x\n"), GetLastError()); return ; }
            _tprintf(_T("SUCCESS\n"));
   
            // Get the values
            _tprintf(_T("RegQueryValueEx..."));
            lResult = RegQueryValueEx(
                hKey,
                MY_VALUES,
                NULL,
                NULL,
                (LPBYTE)lpValues,
                &cbValues
            );
            if (ERROR_SUCCESS != lResult) { _tprintf(_T("ERROR 0x%x\n"), lResult); return ; }
            _tprintf(_T("SUCCESS\n"));
   
            // SHOW THE VALUES
            //
            _tprintf(_T("\n**************************\n"));
            _tprintf(_T("OLD VALUES\n"));
            _tprintf(_T("**************************\n\n"));
            lpValue = lpValues;
            for (; '\0' != *lpValue; lpValue += _tcslen(lpValue) + )
            {
                // Show one value
                _tprintf(_T("%s\n"), lpValue);
            }
            _tprintf(_T("\n**************************\n\n"));
   
            // INSERT A NEW VALUE AFTER A SPECIFIC VALUE IN THE LIST OF VALUES
            //
            // Allocate a new buffer for the old values plus the new one
            _tprintf(_T("malloc..."));
            cbNewValue = (_tcslen(NEW_VALUE) + ) * sizeof(TCHAR);
            cbNewValues = cbValues + cbNewValue;
            lpNewValues = (LPTSTR)malloc(cbNewValues);
            if (NULL == lpNewValues) { _tprintf(_T("ERROR 0x%x\n"), GetLastError()); return ; }
            _tprintf(_T("SUCCESS\n"));        
   
            // Find the value after which we will insert the new one
            lpValue = lpValues;
            lpNewValue = lpNewValues;
            bFound = FALSE;
            for (; '\0' != *lpValue; lpValue += _tcslen(lpValue) + )
            {
                // Copy the current value to the target buffer
                memcpy(lpNewValue, lpValue, (_tcslen(lpValue) + ) * sizeof(TCHAR));
   
                if ( == _tcscmp(lpValue, FIND_VALUE))
                {
                    // The current value is the one we wanted to find
                    bFound = TRUE;
   
                    // Copy the new value to the target buffer
                    lpNewValue += _tcslen(lpValue) + ;
                    memcpy(lpNewValue, NEW_VALUE, (_tcslen(NEW_VALUE) + ) * sizeof(TCHAR));
                    lpNewValue += _tcslen(NEW_VALUE) + ;
                }
                else
                {
                    // This is not the value we want, continue to the next one
                    lpNewValue += _tcslen(lpValue) + ;
                }
            }
            if (!bFound)
            {
                // We didn't find the value we wanted. Insert the new value at the end
                memcpy(lpNewValue, NEW_VALUE, (_tcslen(NEW_VALUE) + ) * sizeof(TCHAR));
                lpNewValue += _tcslen(NEW_VALUE) + ;
            }
            *lpNewValue = *lpValue;
   
            // SHOW THE NEW VALUES
            //
            _tprintf(_T("\n**************************\n"));
            _tprintf(_T("NEW VALUES\n"));
            _tprintf(_T("**************************\n\n"));
            lpNewValue = lpNewValues;
            for (; '\0' != *lpNewValue; lpNewValue += _tcslen(lpNewValue) + )
            {
                // Show one value
                _tprintf(_T("%s\n"), lpNewValue);
            }
            _tprintf(_T("\n**************************\n\n"));
   
            // WRITE THE NEW VALUES BACK TO THE KEY
            //
            _tprintf(_T("RegSetValueEx..."));
            lResult = RegSetValueEx(
                hKey,
                MY_VALUES,
                NULL,
                REG_MULTI_SZ,
                (LPBYTE)lpNewValues,
                cbNewValues
            );
            if (ERROR_SUCCESS != lResult) { _tprintf(_T("ERROR 0x%x\n"), lResult); return ; }
            _tprintf(_T("SUCCESS\n"));
        }
        __finally
        {
            // Clean up
            //
            if (NULL != lpValues) { free(lpValues); }
            if (NULL != lpNewValues) { free(lpNewValues); }
            if (NULL != hKey) { RegCloseKey(hKey); }
   
            //_tprintf(_T("\n<<PRESS ANY KEY>>\n"));
            //_getch();
        }
   
        return ;
    }
   
    // 此模板来自http://blogs.msdn.com/b/alejacma/archive/2009/11/12/how-to-manipulate-reg-multi-sz-values-from-the-registry-c.aspx