注册表操作总结

参考及摘抄自文章：http://www.cnblogs.com/lartely/archive/2011/04/10/2011770.html

              http://blog.csdn.net/sunboy_2050/article/details/7753662

基础知识:

 

注册表的组织方式跟文件目录比较相似，主要分为根键、子键和键值项三部分，与文件目录对应的话就是根目录、子目录和文件。分别介绍一下这三部分：
1.根键：共有5个，分别为HKEY_CLASSES_ROOT，HKEY_CURRENT_USER，HKEY_LOCAL_MACHINE，HKEY_USERS和HKEY_CURRENT_CONFIG，把它们理解成磁盘的五个分区可以了。
2.子键：可以有多个子键和键值项，就像一个目录中可以有多个子目录和多个文件一样。
3.键值项：可以理解为文件，它由三部分组成，分别为：名称、类型、数据。
类型又分为多种主要包括如下：
REG_BINARY 二进制数据
REG_DWORD 32位双字节数据
REG_SZ 以0结尾的字符串
REG_DWORD_BIG_ENDIAN 高位排在底位的双字
REG_EXPAND_SZ 扩展字符串，可以加入变量如%PATH%
REG_LINK UNICODE 符号链接
REG_RESOURCE_LIST 设备驱动程序资源列表
REG_MULTI_SZ 多字符串
注册表数据项的数据类型有8种，但最常用的主要是前3种。

常用API:

 

1.打开/关闭注册表键

LONG WINAPI RegOpenKeyEx(
  _In_        HKEY hKey,         // 父键句柄
  _In_opt_    LPCTSTR lpSubKey,  // 子键的名称
  _Reserved_  DWORD ulOptions,   // 保留项，传0即可
  _In_        REGSAM samDesired, // 访问权限
  _Out_       PHKEY phkResult    // 返回子键的句柄
);

HKEY hKey------

    父键的句柄，可为RegCreateKeyEx或RegOpenKeyEx返回的注册表键句柄

    或为预定义的根键HKEY_CLASSES_ROOT，HKEY_CURRENT_USER，HKEY_LOCAL_MACHINE，HKEY_USERS或HKEY_CURRENT_CONFIG

REGSAM samDesired------

    访问权限，想方便的话可以指定为KEY_ALL_ACCESS，这样什么权限都有了。其他常用的权限还有KEY_READ，KEY_WRITE等。

成功开启子键则返回ERROR_SUCCESS

LONG WINAPI RegCloseKey(
  _In_  HKEY hKey
);

这两个函数需配对使用

[cpp] view plaincopy
 
  1. // 打开注册表键------  
  2. HKEY hKey;  
  3. LPCTSTR lpszSubKey = TEXT("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall");  
  4. int ret = RegOpenKeyEx(HKEY_LOCAL_MACHINE, lpszSubKey, 0, KEY_ALL_ACCESS, &hKey);  
  5. if (ret != ERROR_SUCCESS)  
  6. {  
  7.     // 打开失败  
  8.     ......  
  9. }  
  10.   
  11. ......  
  12.           
  13. // 关闭注册表键------  
  14. RegCloseKey(hKey);  

 

2.获取注册表键的子键及键值的信息

每个注册表键下面都包含子键及键值项，RegQueryInfoKey函数用于获取子键的数量，键值项的数量等信息。

LONG WINAPI RegQueryInfoKey(
  _In_        HKEY hKey,               // 要获取信息的注册表键句柄
  _Out_opt_   LPTSTR lpClass,          // 一般传NULL
  _Inout_opt_ LPDWORD lpcClass,        // 一般传NULL
  _Reserved_  LPDWORD lpReserved,      // NULL
  _Out_opt_   LPDWORD lpcSubKeys,      // hKey下的子键数量
  _Out_opt_   LPDWORD lpcMaxSubKeyLen, // hKey下的子键名称的最大长度(不包含结尾的null字符)
  _Out_opt_   LPDWORD lpcMaxClassLen,  // 一般传NULL
  _Out_opt_   LPDWORD lpcValues,       // hKey下的键值的数量
  _Out_opt_   LPDWORD lpcMaxValueNameLen, // hKey下键值Name的最大长度(不包含结尾的null字符)
  _Out_opt_   LPDWORD lpcMaxValueLen,     // hKey下的键值Data的最大长度(in bytes)
  _Out_opt_   LPDWORD lpcbSecurityDescriptor, // 安全描述符长度，一般传NULL
  _Out_opt_   PFILETIME lpftLastWriteTime     // 最后修改时间，一般传NULL
);

通过RegQueryInfoKey获取了子键及键值项的信息后，这才知道子键的数量，键值项的数量等信息，后面就可以通过RegEnumKeyEx枚举子键信息，通过RegEnumValue枚举键值项信息。

 

[cpp] view plaincopy
 
  1. DWORD dwSubKeyCnt;          // 子键的数量  
  2. DWORD dwSubKeyNameMaxLen;   // 子键名称的最大长度(不包含结尾的null字符)  
  3. DWORD dwKeyValueCnt;        // 键值项的数量  
  4. DWORD dwKeyValueNameMaxLen; // 键值项名称的最大长度(不包含结尾的null字符)  
  5. DWORD dwKeyValueDataMaxLen; // 键值项数据的最大长度(in bytes)  
  6. int ret = RegQueryInfoKey(  
  7.     hKey,  
  8.     NULL,  
  9.     NULL,  
  10.     NULL,  
  11.     &dwSubKeyCnt,  
  12.     &dwSubKeyNameMaxLen,  
  13.     NULL,  
  14.     &dwKeyValueCnt,  
  15.     &dwKeyValueNameMaxLen,  
  16.     &dwKeyValueDataMaxLen,  
  17.     NULL,  
  18.     NULL);  
  19. if (ret != ERROR_SUCCESS) // Error  
  20. {  
  21.     ......  
  22. }  

3.枚举子键信息

LONG WINAPI RegEnumKeyEx(
  _In_         HKEY hKey,
  _In_         DWORD dwIndex,      // 索引，从0开始
  _Out_        LPTSTR lpName,      // 接收子键的名称
  _Inout_      LPDWORD lpcName,    // lpName的大小(in characters,包含null)
  _Reserved_   LPDWORD lpReserved, // NULL
  _Inout_      LPTSTR lpClass,     // 一般传NULL
  _Inout_opt_  LPDWORD lpcClass,   // 一般传NULL
  _Out_opt_    PFILETIME lpftLastWriteTime  // 一般传NULL
);

前面通过RegQueryInfoKey获取了hKey下子键的数量以及子键名称的最大长度，那么接下来通过RegEnumKeyEx就可以获取每个子键的名称了。为什么要获取子键的名称，因为获取了这个名称之后，就可以通过RegOpenKeyEx开启子键获得其句柄。

整个流程差不多是这样子的：RegQueryInfoKey-->获得某注册表键下的子键的数量及子键名称的最大长度-->RegEnumKeyEx-->枚举获取每个子键的名称-->RegOpenKeyEx-->开启子键句柄-->做你想要的操作。

lpName------

    前面通过RegQueryInfoKey获取了子键名称的最大长度（没有包含结尾的null字符），所有可以通过定义一个[最大长度+1]大小的Buffer来接收

lpcName------

    RegQueryInfoKey获取的子键名称的最大长度 + 1

 

[cpp] view plaincopy
 
  1. //  
  2. // 以下代码中的变量dwSubKeyNameMaxLen&dwSubKeyCnt由  
  3. // RegQueryInfoKey获取  
  4. //  
  5. LPTSTR lpszSubKeyName = new TCHAR[dwSubKeyNameMaxLen+1];  
  6. for (int index = 0; index < dwSubKeyCnt; ++index)  
  7. {  
  8.     memset(lpszSubKeyName, 0, sizeof(TCHAR)*(dwSubKeyNameMaxLen+1));  
  9.     DWORD dwNameCnt = dwSubKeyNameMaxLen + 1;  
  10.     int ret = RegEnumKeyEx(  
  11.         hKey,  
  12.         index,  
  13.         lpszSubKeyName,  
  14.         &dwNameCnt,  
  15.         NULL,  
  16.         NULL,  
  17.         NULL,  
  18.         NULL);  
  19.     if (ret != ERROR_SUCCESS)  
  20.     {  
  21.         ......  
  22.     }  
  23. }  
  24. delete[] lpszSubKeyName;  

 

4.枚举键值项信息

LONG WINAPI RegEnumValue(
  _In_         HKEY hKey,
  _In_         DWORD dwIndex,         // 索引，从0开始
  _Out_        LPTSTR lpValueName,    // 接收键值项的名称
  _Inout_      LPDWORD lpcchValueName,// lpValueName的大小，包含null character
  _Reserved_   LPDWORD lpReserved,    // NULL
  _Out_opt_    LPDWORD lpType,        // 接收键值项的类型
  _Out_opt_    LPBYTE lpData,         // 接收键值项的数据
  _Inout_opt_  LPDWORD lpcbData       // lpData的Buffer大小(in bytes)
);

前面通过RegQueryInfoKey获取了hKey下键值项的数量以及键值项名称的最大长度，键值项数据的最大长度，那么接下来通过RegEnumValue就可以获取每个键值项的名称、类型、数据。

 

[cpp] view plaincopy
 
  1. //  
  2. // 以下代码中变量:dwKeyValueCnt & dwKeyValueNameMaxLen &  
  3. //                dwKeyValueDataMaxLen  
  4. // 均为通过RegQueryInfoKey获取的  
  5. //  
  6. for (unsigned int index = 0; index < dwKeyValueCnt; ++index)  
  7. {  
  8.     LPTSTR lpszKeyValueName = new TCHAR[dwKeyValueNameMaxLen + 1];  
  9.     memset(lpszKeyValueName, 0, sizeof(TCHAR)*(dwKeyValueNameMaxLen + 1));  
  10.     DWORD  dwNameCnt = dwKeyValueNameMaxLen + 1;  
  11.     DWORD  dwKeyValueType;  
  12.     LPBYTE lpbKeyValueData = new BYTE[dwKeyValueDataMaxLen];  
  13.     DWORD  dwKeyValueDataLen;  
  14.       
  15.     int ret = RegEnumValue(  
  16.         hKey,   
  17.         index,   
  18.         lpszKeyValueName,  
  19.         &dwNameCnt,   
  20.         NULL,   
  21.         &dwKeyValueType,    
  22.         lpbKeyValueData,  
  23.         &dwKeyValueDataLen);  
  24.     if (ret != ERROR_SUCCESS)  
  25.     {  
  26.         ......  
  27.     }  
  28.     delete[] lpszKeyValueName;  
  29.     delete[] lpbKeyValueData;  
  30. }  

5.由键值项名称获取键值项的类型及键值项数据

LONG WINAPI RegQueryValueEx(
  _In_         HKEY hKey,
  _In_opt_     LPCTSTR lpValueName, // 键值项名称
  _Reserved_   LPDWORD lpReserved,  // NULL
  _Out_opt_    LPDWORD lpType,      // 接收键值项类型
  _Out_opt_    LPBYTE lpData,       // 接收键值项数据
  _Inout_opt_  LPDWORD lpcbData     // lpData的Buffer大小(in bytes)
);

有时候，我们知道某注册表键下的键值项的名称，而想获取键值项的类型及键值项数据，就可以通过该函数获取。

比如：我们知道HKEY_CURRENT_USER\Environment注册表键下存在名为"Path"的键值项，通过该函数就可以获取其值。

通常情况下，虽然我们知道键值项的名称，却不知道键值项数据的大小，也即lpData该如何定义？可以分两步实现：一、调用RegQueryValueEx，但传lpData为NULL，函数执行成功后，lpcbData会返回键值项数据的大小。二、根据上一步获取的键值项数据的大小，new一个对应大小的Buffer，然后再调用RegQueryValueEx，传递lpData为新开辟的Buffer，这样就可以了。

 

[cpp] view plaincopy
 
  1. // 获取键值项Data的大小  
  2. LPCTSTR lpszKeyValueName = TEXT("???");  
  3. DWORD dwKeyValueType;  
  4. DWORD dwKeyValueDataSize;  
  5. int ret = RegQueryValueEx(hKey, lpszKeyValueName, NULL, &dwKeyValueType, NULL, &dwKeyValueDataSize);  
  6. if (ret != ERROR_SUCCESS)  
  7. {  
  8.     ......  
  9. }  
  10.   
  11. // 获取键值项Data  
  12. LPBYTE lpbKeyValueData = new BYTE[dwKeyValueDataSize];  
  13. ret = RegQueryValueEx(hKey, lpszKeyValueName, NULL, &dwKeyValueType, lpbKeyValueData, &dwKeyValueDataSize);  
  14. if (ret != ERROR_SUCCESS)  
  15. {  
  16.     ......  
  17. }  
  18.   
  19. delete[] lpbKeyValueData;  

6.设置键值项的值/新建键值项

LONG RegSetValueEx(
  HKEY hKey,
  LPCWSTR lpValueName,
  DWORD Reserved,
  DWORD dwType,
  const BYTE* lpData,
  DWORD cbData
);

该函数也可以新建键值项，当lpValueName指定名称的键值项不存在时，会新建键值项。

7.删除键值项

LONG RegDeleteValue( 
  HKEY hKey, 
  LPCWSTR lpValueName 
); 

8.创建、删除子键

LONG RegCreateKeyEx( 
  HKEY hKey, 
  LPCWSTR lpSubKey, 
  DWORD Reserved, 
  LPWSTR lpClass, 
  DWORD dwOptions, 
  REGSAM samDesired, 
  LPSECURITY_ATTRIBUTES lpSecurityAttributes, 
  PHKEY phkResult, 
  LPDWORD lpdwDisposition 
); 
LONG WINAPI RegDeleteKey(
  _In_  HKEY hKey,
  _In_  LPCTSTR lpSubKey
);

 

 

 

示例程序一：读取注册表获取计算机上已安装程序的信息

 

Windows 系统中，安装程序都可以在注册表 HKEY_LOCAL_MACHINE\SoftWare\Microsoft\Windows\CurrentVersion\Uninstall 获取，并且xp、vista、win7、win8都一样

以下示例程序中：

结构体ApplicationInfoA用于记录每个安装程序的具体信息，至于为何在名称后面加A，主要是为了表明其下的信息全是用string记录的。

函数GetAllInstalledAppInfoA用于获取计算机上已安装程序的全部信息，它接受vector<ApplicationInfoA>引用类型的参数，并将获取的全部信息存放在该vector中。该程序执行成功返回0，执行失败则返回-1。

main()函数中演示了怎么使用：

vector<ApplicationInfoA> vAppInfo;     

GetAllInstalledAppInfoA(vAppInfo);

在获取了安装程序的信息后，输出到D盘下的InstalledAppInfo.txt文件中。

 

[cpp] view plaincopy
 
  1. #include <windows.h>  
  2. #include <iostream>  
  3. #include <TCHAR.H>  
  4. #include <vector>  
  5.   
  6. using namespace std;  
  7.   
  8. //  
  9. // 用于记录安装软件信息的结构体  
  10. //  
  11. struct ApplicationInfoA  
  12. {  
  13.     string strName;            // 软件名  
  14.     string strDisplayName;     // 显示的软件名  
  15.     string strPublisher;       // 发布者  
  16.     string strVersion;         // 版本  
  17.     string strDisplayVersion;  // 显示的版本  
  18.     string strInstallLocation; // 安装的位置  
  19. };  
  20.   
  21. //  
  22. // 获取具体的程序的键值Data  
  23. // hKey [in]  
  24. //     --- 指向HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall的子键句柄  
  25. // lpszKeyValueName [in]  
  26. //     --- hKey下面的子键名称  
  27. // lpszKeyValueName [in]  
  28. //     --- 正如其名,键值的名称  
  29. // strKeyValue [out]  
  30. //     --- 键值的Data  
  31. //  
  32. int _GetAppInfoA_(HKEY hKey, LPCSTR lpszAppName, LPCSTR lpszKeyValueName, string& strKeyValue)  
  33. {  
  34.     int ret;  
  35.   
  36.     // 打开已安装软件的注册表键------------------------------------------------  
  37.     HKEY hInstallAppKey;  
  38.     ret = RegOpenKeyEx(hKey, lpszAppName, 0, KEY_ALL_ACCESS, &hInstallAppKey);  
  39.     if (ret != ERROR_SUCCESS)  
  40.     {  
  41.         return -1;  
  42.     }  
  43.   
  44.     // 获取已安装软件的注册表键的键值------------------------------------------  
  45.     // 1.获取字符串大小(默认为字符串即REG_SZ)  
  46.     DWORD dwKeyValueType = REG_SZ;  
  47.     DWORD dwKeyValueDataSize = 0;  
  48.     ret = RegQueryValueExA(  
  49.         hInstallAppKey,  
  50.         lpszKeyValueName,  
  51.         NULL,  
  52.         &dwKeyValueType,  
  53.         NULL,  
  54.         &dwKeyValueDataSize);  
  55.     if (ret == ERROR_FILE_NOT_FOUND)  
  56.     {  
  57.         RegCloseKey(hInstallAppKey);  
  58.         return 0;  
  59.     }  
  60.     else if (ret != ERROR_SUCCESS)  
  61.     {  
  62.         RegCloseKey(hInstallAppKey);  
  63.         return -1;  
  64.     }  
  65.   
  66.     // 2.获取字符串值  
  67.     if (dwKeyValueType != REG_SZ)   // 如果不是字符串类型则返回,有的安装程序此项不为字符串而为其他类型,忽略  
  68.     {  
  69.         RegCloseKey(hInstallAppKey);  
  70.         return 0;  
  71.     }  
  72.     LPSTR lpszKeyValueData = new char[dwKeyValueDataSize + 1];  
  73.     memset(lpszKeyValueData, 0, dwKeyValueDataSize + 1);  
  74.     ret = RegQueryValueExA(  
  75.         hInstallAppKey,  
  76.         lpszKeyValueName,  
  77.         NULL,  
  78.         &dwKeyValueType,  
  79.         (LPBYTE)lpszKeyValueData,  
  80.         &dwKeyValueDataSize);  
  81.     if (ret != ERROR_SUCCESS)  
  82.     {  
  83.         delete[] lpszKeyValueData;  
  84.         RegCloseKey(hInstallAppKey);  
  85.         return -1;  
  86.     }  
  87.     strKeyValue = lpszKeyValueData;  
  88.     delete[] lpszKeyValueData;  
  89.   
  90.     // 关闭注册表键------------------------------------------------------------  
  91.     RegCloseKey(hInstallAppKey);  
  92.   
  93.     return 0;  
  94. }  
  95.   
  96.   
  97. //  
  98. // 获取系统安装的程序信息并存储于参数vector中  
  99. // 成功执行返回0  
  100. // 执行失败则返回-1  
  101. //  
  102. int GetAllInstalledAppInfoA(vector<ApplicationInfoA>& vAppInfo)  
  103. {  
  104.     int ret;  
  105.   
  106.     // 打开注册表键------------------------------------------------------------  
  107.     HKEY hKey;  
  108.     LPCSTR lpszSubKey = "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall";  
  109.     ret = RegOpenKeyExA(HKEY_LOCAL_MACHINE, lpszSubKey, 0, KEY_ALL_ACCESS, &hKey);  
  110.     if (ret != ERROR_SUCCESS)  
  111.     {  
  112.         return -1;  
  113.     }  
  114.   
  115.     // 获取子键&键值信息-------------------------------------------------------  
  116.     DWORD dwSubKeysCnt;           // 子键数量  
  117.     DWORD dwMaxSubKeyNameLen;     // 子键名字的最大长度(not including the terminating null character)  
  118.     DWORD dwKeyValueCnt;          // 键值的数量  
  119.     DWORD dwMaxKeyValueNameLen;   // 键值名字的最大长度(not including the terminating null character)  
  120.     DWORD dwMaxKeyValueDataLen;   // 键值数据的最大长度(in Bytes)  
  121.   
  122.     ret = RegQueryInfoKey(  
  123.         hKey,  
  124.         NULL,  
  125.         NULL,  
  126.         NULL,  
  127.         &dwSubKeysCnt,  
  128.         &dwMaxSubKeyNameLen,  
  129.         NULL,  
  130.         &dwKeyValueCnt,  
  131.         &dwMaxKeyValueNameLen,  
  132.         &dwMaxKeyValueDataLen,  
  133.         NULL,  
  134.         NULL);  
  135.     if (ret != ERROR_SUCCESS)  
  136.     {  
  137.         RegCloseKey(hKey);  
  138.         return -1;  
  139.     }  
  140.   
  141.     // 枚举子键信息------------------------------------------------------------  
  142.     DWORD dwIndex;  
  143.     LPSTR lpszSubKeyName = new char[dwMaxSubKeyNameLen + 1];  
  144.     DWORD dwNameLen = dwMaxSubKeyNameLen + 1;  
  145.   
  146.     for (dwIndex = 0; dwIndex < dwSubKeysCnt; ++dwIndex)  
  147.     {  
  148.         dwNameLen = dwMaxSubKeyNameLen + 1;  
  149.         memset(lpszSubKeyName, 0, dwMaxSubKeyNameLen + 1);  
  150.   
  151.         ret = RegEnumKeyEx(  
  152.             hKey,  
  153.             dwIndex,  
  154.             lpszSubKeyName,  
  155.             &dwNameLen,  
  156.             NULL,  
  157.             NULL,  
  158.             NULL,  
  159.             NULL);  
  160.         if (ret != ERROR_SUCCESS)  
  161.         {  
  162.             RegCloseKey(hKey);  
  163.             delete[] lpszSubKeyName;  
  164.             return -1;  
  165.         }  
  166.   
  167.         //************获取具体的程序的安装信息BEG*************  
  168.         ApplicationInfoA appInfo;  
  169.         appInfo.strName = lpszSubKeyName;  
  170.         _GetAppInfoA_(hKey, lpszSubKeyName, "DisplayName", appInfo.strDisplayName);  
  171.         _GetAppInfoA_(hKey, lpszSubKeyName, "Publisher", appInfo.strPublisher);  
  172.         _GetAppInfoA_(hKey, lpszSubKeyName, "Version", appInfo.strVersion);  
  173.         _GetAppInfoA_(hKey, lpszSubKeyName, "DisplayVersion", appInfo.strDisplayVersion);  
  174.         _GetAppInfoA_(hKey, lpszSubKeyName, "InstallLocation", appInfo.strInstallLocation);  
  175.         vAppInfo.push_back(appInfo);  
  176.         //************获取具体的程序的安装信息END*************  
  177.     }  
  178.   
  179.     delete[] lpszSubKeyName;  
  180.   
  181.     // 关闭注册表键------------------------------------------------------------  
  182.     RegCloseKey(hKey);  
  183.     return 0;  
  184. }  
  185.   
  186. int main()  
  187. {  
  188.     cout << "Reg Demo Test" << endl;  
  189.   
  190.     vector<ApplicationInfoA> vAppInfo;  
  191.     cout << GetAllInstalledAppInfoA(vAppInfo) << endl;  
  192.   
  193.     //输出到文件  
  194.     vector<ApplicationInfoA>::iterator iter = vAppInfo.begin();  
  195.     FILE *fp = fopen("D:\\InstalledAppInfo.txt", "a");  
  196.     while (iter != vAppInfo.end())  
  197.     {  
  198.         fprintf(fp, "----------------\n");  
  199.         fprintf(fp, "Name: %s\n DisplayName: %s\n Publisher: %s\n Version: %s\n DisplayVersion: %s\n InstallLocation: %s\n",   
  200.             iter->strName.c_str(), iter->strDisplayName.c_str(),  
  201.             iter->strPublisher.c_str(), iter->strVersion.c_str(),   
  202.             iter->strDisplayVersion.c_str(), iter->strInstallLocation.c_str());  
  203.         fprintf(fp, "----------------\n\n");  
  204.         ++iter;  
  205.     }  
  206.     fclose(fp);  
  207.   
  208.     return 0;  
  209. }  

 

示例程序二：增加Path环境变量

 

我们常常需要手工添加环境变量，如下图所示：

那么怎样用程序实现呢？环境变量的配置存储在注册表当中，可以通过读写注册表来实现读写环境变量。

系统变量存储在注册表的如下位置：HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\Environment

而用户变量则存储在注册表的如下位置：HKEY_CURRENT_USER\Environment

下面示例程序用于向系统变量中的Path环境变量中增加内容。

main函数中调用AddPathEnvValue(";HelloKitty")就用于向Path环境变量后面添加;HelloKitty。当然程序中有防呆机制，如果系统变量下刚开始没有Path环境变量则先新增Path环境变量。程序执行成功返回0，执行失败返回-1。

代码如下：

 

[cpp] view plaincopy
 
    1. #include <windows.h>  
    2. #include <iostream>  
    3.   
    4. using namespace std;  
    5.   
    6. //  
    7. // 为系统变量下的Path环境变量增加内容lpszPathValue  
    8. // 成功则返回0  
    9. // 失败则返回-1  
    10. // 若刚开始Path环境变量为"D:\\123"  
    11. // 则调用AddPathEnvValue(";HelloKitty")后为"D:\\123;HelloKitty"  
    12. //  
    13. int AddPathEnvValue(LPCSTR lpszPathValue)  
    14. {  
    15.     int ret;  
    16.   
    17.     // 打开注册表键----------------------------------------  
    18.     HKEY hKey;  
    19.     LPCSTR lpszSubKey = "SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Environment";  
    20.     ret = RegOpenKeyExA(HKEY_LOCAL_MACHINE, lpszSubKey, 0, KEY_ALL_ACCESS, &hKey);  
    21.     if (ERROR_SUCCESS != ret)  
    22.     {  
    23.         cout << "RegOpenKeyExA():Error" << endl;  
    24.         return -1;  
    25.     }  
    26.       
    27.     // 读取注册表键的键值"Path"----------------------------  
    28.     // 1.获取KeyValueData即字符串的大小  
    29.     LPCSTR lpszKeyValueName = "Path";  
    30.     DWORD  dwKeyValueType = REG_EXPAND_SZ;  
    31.     DWORD  dwKeyValueDataSize = 0;     
    32.     ret = RegQueryValueExA(hKey, lpszKeyValueName, NULL, &dwKeyValueType, NULL, &dwKeyValueDataSize);  
    33.     if (ret == ERROR_FILE_NOT_FOUND)  
    34.     {  
    35.         //不存在Path环境变量则新增一个Path环境变量  
    36.         ret = RegSetValueExA(hKey, lpszKeyValueName, 0, REG_EXPAND_SZ, (const BYTE*)"", 1);  
    37.         if (ret != ERROR_SUCCESS)  
    38.         {  
    39.             cout << "RegSetValueExA():Error" << endl;  
    40.             RegCloseKey(hKey);  
    41.             return -1;  
    42.         }  
    43.     }  
    44.     else if (ret != ERROR_SUCCESS)  
    45.     {  
    46.         cout << "RegQueryValueExA():Error" << endl;  
    47.         RegCloseKey(hKey);  
    48.         return -1;  
    49.     }  
    50.     else if (dwKeyValueType != REG_EXPAND_SZ)  
    51.     {  
    52.         cout << "It is impossible" << endl;  
    53.         cout << dwKeyValueType << endl;  
    54.         RegCloseKey(hKey);  
    55.         return -1;  
    56.     }  
    57.   
    58.     // 2.获取KeyValueData即字符串的值  
    59.     CHAR *lpszKeyValueData = new CHAR[dwKeyValueDataSize + 1];  
    60.     memset(lpszKeyValueData, 0, dwKeyValueDataSize + 1);  
    61.     ret = RegQueryValueExA(hKey, lpszKeyValueName, NULL, &dwKeyValueType, (LPBYTE)lpszKeyValueData, &dwKeyValueDataSize);  
    62.     if (ret != ERROR_SUCCESS)  
    63.     {  
    64.         cout << "RegQueryValueExA():Error" << endl;  
    65.         RegCloseKey(hKey);  
    66.         delete[] lpszKeyValueData;  
    67.         return -1;  
    68.     }  
    69.   
    70.     // 在原注册表键值的基础上添加新的值  
    71.     unsigned int nLen = strlen(lpszPathValue);  
    72.     nLen += strlen(lpszKeyValueData);  
    73.     CHAR *lpszKeyValueData_New = new CHAR[nLen + 1];  
    74.     memset(lpszKeyValueData_New, 0, nLen + 1);  
    75.     sprintf(lpszKeyValueData_New, "%s%s", lpszKeyValueData, lpszPathValue);  
    76.     ret = RegSetValueExA(hKey, lpszKeyValueName, 0, REG_EXPAND_SZ, (const BYTE*)lpszKeyValueData_New, strlen(lpszKeyValueData_New) + 1);  
    77.     if (ret != ERROR_SUCCESS)  
    78.     {  
    79.         cout << "RegSetValueExA:Error" << endl;  
    80.         RegCloseKey(hKey);  
    81.         delete[] lpszKeyValueData;  
    82.         delete[] lpszKeyValueData_New;  
    83.   
    84.         return -1;  
    85.     }  
    86.   
    87.   
    88.     delete[] lpszKeyValueData;  
    89.     delete[] lpszKeyValueData_New;  
    90.   
    91.     // 关闭注册表键----------------------------------------  
    92.     RegCloseKey(hKey);  
    93.   
    94.     return 0;  
    95. }  
    96.   
    97. int main()  
    98. {  
    99.     cout << AddPathEnvValue(";HelloKitty") << endl;  
    100.   
    101.     return 0;  
    102. }  
posted @ 2015-02-01 20:58  廖先生  阅读(428)  评论(0)  编辑  收藏  举报