注册表操作总结

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

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

基础知识:

常用API:

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. 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. int ret = RegEnumValue(
15. hKey,
16. index,
17. lpszKeyValueName,
18. &dwNameCnt,
19. NULL,
20. &dwKeyValueType,
21. lpbKeyValueData,
22. &dwKeyValueDataLen);
23. if (ret != ERROR_SUCCESS)
24. {
25. ......
26. }
27. delete[] lpszKeyValueName;
28. delete[] lpbKeyValueData;
29. }

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. // 获取键值项Data
11. LPBYTE lpbKeyValueData = new BYTE[dwKeyValueDataSize];
12. ret = RegQueryValueEx(hKey, lpszKeyValueName, NULL, &dwKeyValueType, lpbKeyValueData, &dwKeyValueDataSize);
13. if (ret != ERROR_SUCCESS)
14. {
15. ......
16. }
17. 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
);

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

以下示例程序中：

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

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