C++ 注册表

最新推荐文章于 2022-03-03 16:12:10 发布
最新推荐文章于 2022-03-03 16:12:10 发布
阅读量897 收藏
点赞数
分类专栏： C++ VC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24127015/article/details/88975827
版权

百科：https://baike.baidu.com/item/%E6%B3%A8%E5%86%8C%E8%A1%A8/101856?fr=aladdin

CRegKey:https://blog.csdn.net/pbymw8iwm/article/details/6931946

HKEY_CURRENT_USER：管理系统当前的用户信息。在这个根键中保存了本地计算机中存放的当前登录的用户信息，包括用户登录用户名和暂存的密码。在用户登录Windows时，其信息从HKEY_USERS中相应的项拷贝到HKEY_CURRENT_USER中。

HKEY_CLASSES_ROOT是应用程序运行时必需的信息，和HKEY_LOCAL_MACHINE\SOFTWARE\Classes是一样的，但是在HKEY_CLASSES_ROOT窗编辑相对来说显得更容易和有条理。

在微软的Windows操作系统中，HKEY_LOCAL_MACHINE保存了注册表里的所有与这台计算机有关的配置信息，只是一个公共配置信息单元，对于读者来说，只需做一个大致的了解即可。

HKEY_USERS仅包含了缺省用户设置和登录用户的信息。虽然它包含了所有独立用户的设置，但在用户未登录时用户的设置是不可用的。这些设置告诉系统哪些图标会被使用，什么组可用，哪个开始菜单可用，哪些颜色和字体可用，和控制面板上什么选项和设置可用。

#define HKEY_CLASSES_ROOT                   (( HKEY ) (ULONG_PTR)((LONG)0x80000000) )
#define HKEY_CURRENT_USER                   (( HKEY ) (ULONG_PTR)((LONG)0x80000001) )
#define HKEY_LOCAL_MACHINE                  (( HKEY ) (ULONG_PTR)((LONG)0x80000002) )
#define HKEY_USERS                          (( HKEY ) (ULONG_PTR)((LONG)0x80000003) )
#define HKEY_PERFORMANCE_DATA               (( HKEY ) (ULONG_PTR)((LONG)0x80000004) )
#define HKEY_PERFORMANCE_TEXT               (( HKEY ) (ULONG_PTR)((LONG)0x80000050) )
#define HKEY_PERFORMANCE_NLSTEXT            (( HKEY ) (ULONG_PTR)((LONG)0x80000060) )
#if(WINVER >= 0x0400)
#define HKEY_CURRENT_CONFIG                 (( HKEY ) (ULONG_PTR)((LONG)0x80000005) )
#define HKEY_DYN_DATA                       (( HKEY ) (ULONG_PTR)((LONG)0x80000006) )
#define HKEY_CURRENT_USER_LOCAL_SETTINGS    (( HKEY ) (ULONG_PTR)((LONG)0x80000007) )

RegKeyEx.h

#pragma once
#include <atlbase.h>
#include <iostream>
#include <string>
class CRegKeyEx :public CRegKey
{
public:
	CRegKeyEx();
	~CRegKeyEx();
public:
	bool QueryStringValue(HKEY hKey,const std::wstring& strRegPath,const std::wstring& strKey,std::wstring& strValue,REGSAM samDesired = KEY_WOW64_64KEY);
	bool SetStringValue(HKEY hKey, const std::wstring& strRegPath, const std::wstring& strKey, std::wstring& strValue, REGSAM samDesired = KEY_WOW64_64KEY);
	bool QueryDWORDValue(HKEY hKey, const std::wstring& strRegPath, const std::wstring& strKey, DWORD& dwValue, REGSAM samDesired = KEY_WOW64_64KEY);
	bool SetDWORDValue(HKEY hKey, const std::wstring& strRegPath, const std::wstring& strKey, DWORD dwValue,  REGSAM samDesired = KEY_WOW64_64KEY);
	bool SetBinaryValue(HKEY hKey, const std::wstring& strRegPath, const std::wstring& strKey, unsigned char* const bzValue, ULONG nBytes, REGSAM samDesired = KEY_WOW64_64KEY);
	bool RecurseDeleteKey(HKEY hKey, const std::wstring& strRegPath, const std::wstring& strKey, REGSAM samDesired = KEY_WOW64_64KEY);

};

RegKeyEx.cpp

#include "stdafx.h"
#include "RegKeyEx.h"


CRegKeyEx::CRegKeyEx()
{
}


CRegKeyEx::~CRegKeyEx()
{
}

bool CRegKeyEx::QueryStringValue(HKEY hKey, const std::wstring& strRegPath, const std::wstring& strKey, std::wstring& strValue, REGSAM samDesired/* = KEY_WOW64_64KEY*/)
{
	bool bSuccess = false;
	if (!strRegPath.empty())
	{
		ULONG nChars = MAX_PATH * 10;
		WCHAR szValue[MAX_PATH * 10] = { 0 };
		if (ERROR_SUCCESS == CRegKey::Open(hKey, strRegPath.c_str(), KEY_READ | samDesired)
			&& ERROR_SUCCESS == CRegKey::QueryStringValue(strKey.c_str(), szValue, &nChars))
		{
			strValue = szValue;
			bSuccess = true;
		}
	}
	return bSuccess;
}

bool CRegKeyEx::SetStringValue(HKEY hKey, const std::wstring& strRegPath, const std::wstring& strKey, std::wstring& strValue, REGSAM samDesired/* = KEY_WOW64_64KEY*/)
{
	bool bSuccess = false;
	if (false == strRegPath.empty() && (false == strKey.empty() || false == strValue.empty()))
	{
		if (ERROR_SUCCESS == CRegKey::Create(hKey, strRegPath.c_str(), nullptr, REG_OPTION_NON_VOLATILE, KEY_WRITE | samDesired)
			&& ERROR_SUCCESS == CRegKey::SetStringValue(strKey.c_str(), strValue.c_str()))
		{
			bSuccess = true;
		}
	}
	return bSuccess;
}

bool CRegKeyEx::QueryDWORDValue(HKEY hKey, const std::wstring& strRegPath, const std::wstring& strKey, DWORD& dwValue, REGSAM samDesired/* = KEY_WOW64_64KEY*/)
{
	bool bSuccess = false;
	if (false == strRegPath.empty())
	{
		ULONG nChars = MAX_PATH * 10;
		WCHAR szValue[MAX_PATH * 10] = { 0 };

		if (ERROR_SUCCESS == CRegKey::Open(hKey, strRegPath.c_str(), KEY_READ | KEY_QUERY_VALUE | samDesired)
			&& ERROR_SUCCESS == CRegKey::QueryDWORDValue(strKey.c_str(), dwValue))
		{
			bSuccess = true;
		}
	}
	return bSuccess;
}

bool CRegKeyEx::SetDWORDValue(HKEY hKey, const std::wstring& strRegPath, const std::wstring& strKey, DWORD dwValue, REGSAM samDesired/* = KEY_WOW64_64KEY*/)
{
	bool bSuccess = false;
	if (false == strRegPath.empty() && (false == strKey.empty()))
	{
		if (ERROR_SUCCESS == CRegKey::Create(hKey, strRegPath.c_str(), nullptr, REG_OPTION_NON_VOLATILE, KEY_WRITE | samDesired)
			&& ERROR_SUCCESS == CRegKey::SetDWORDValue(strKey.c_str(), dwValue))
		{
			bSuccess = true;
		}
	}
	return bSuccess;
}

bool CRegKeyEx::SetBinaryValue(HKEY hKey, const std::wstring& strRegPath, const std::wstring& strKey, unsigned char* const bzValue, ULONG nBytes, REGSAM samDesired/* = KEY_WOW64_64KEY*/)
{
	bool bSuccess = false;
	if (false == strRegPath.empty() && (false == strKey.empty()))
	{
		if (ERROR_SUCCESS == Create(hKey, strRegPath.c_str(), nullptr, REG_OPTION_NON_VOLATILE, KEY_WRITE | samDesired)
			&& ERROR_SUCCESS == CRegKey::SetBinaryValue(strKey.c_str(), bzValue, nBytes))
		{
			bSuccess = true;
		}
	}
	return bSuccess;
}

bool CRegKeyEx::RecurseDeleteKey(HKEY hKey, const std::wstring& strRegPath, const std::wstring& strKey, REGSAM samDesired/* = KEY_WOW64_64KEY*/)
{
	bool bSuccess = false;
	if (ERROR_SUCCESS == Open(hKey, strRegPath.c_str(), KEY_WRITE | samDesired))
	{
		LONG nResult = CRegKey::RecurseDeleteKey(strKey.c_str());
		if (ERROR_SUCCESS == nResult || ERROR_FILE_NOT_FOUND == nResult)
		{
			bSuccess = true;
		}
		else
		{
			nResult = CRegKey::DeleteSubKey(strKey.c_str());
			if (ERROR_SUCCESS == nResult || ERROR_FILE_NOT_FOUND == nResult)
			{
				bSuccess = true;
			}
		}
	}
	return bSuccess;
}

main.cpp

// ConsoleApplication1.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "RegKeyEx.h"

#define REG_PATH L"Software\\chaoge"
#define REG_SCORE	L"Score"
#define REG_AGE		L"Age"
#define REG_BINARY	L"Binary"
int main()
{
	CRegKeyEx objRegKeyEx;
	std::wstring strScore = L"cet 4 100";
	objRegKeyEx.SetStringValue(HKEY_CURRENT_USER, REG_PATH, REG_SCORE,strScore);
	std::wstring strRet;
	objRegKeyEx.QueryStringValue(HKEY_CURRENT_USER, REG_PATH, REG_SCORE, strRet);
	std::wcout << strRet << std::endl;

	objRegKeyEx.SetDWORDValue(HKEY_CURRENT_USER, REG_PATH, REG_AGE, 18);
	DWORD dwRet;
	objRegKeyEx.QueryDWORDValue(HKEY_CURRENT_USER, REG_PATH, REG_AGE, dwRet);
	std::wcout << dwRet << std::endl;

	unsigned char buf[2] = { 0x02,0x03 };
	objRegKeyEx.SetBinaryValue(HKEY_CURRENT_USER, REG_PATH, REG_BINARY, buf, 2);

	objRegKeyEx.RecurseDeleteKey(HKEY_CURRENT_USER, REG_PATH, REG_BINARY);

    return 0;
}

 

qq_24127015
关注
专栏目录
c++ 操作注册表
01-14 1605
1.       注册表简介 注册表是为Windows NT和Windows95中所有32位硬件/驱动和32位应用程序设计的数据文件，用于存储系统和应用程序的设置信息。16位驱动在Winnt (Windows New Technology)下无法工作，所以所有设备都通过注册表来控制，一般这些是通过BIOS（基本输入输出系统）来控制的。在Win95下，16位驱动会继续以实模式方式设备工作，它们使用
C++注册表读写字符串
weixin_45756344的博客
10-28 491
//读取注册表信息 void OnBnClickedQuery() { HKEY hKey; LPCTSTR data_Set = TEXT("SOFTWARE\\KeyID"); TCHAR lpszValue[16]; DWORD dwSize = sizeof(lpszValue); DWORD dwType = REG_SZ; RegOpenKeyEx(HKEY_CURRENT_USER, data_Set, NULL, KEY_READ, &am...
C++ 注册表操作
aizongsai2251的博客
07-16 363
一、 LONG RegOpenKeyEx( HKEY hKey, // 需要打开的主键的名称 LPCTSTR lpSubKey, //需要打开的子键的名称 DWORD ulOptions, // 保留，设为0 REGSAM samDesired, // 安全访问标记，也就是权限 PHKEY phkResult // 得到的将要打开键的句柄 ) hKey [输入] 当前打开或者以下预...
C++ 注册表的实现
qq_43331089的博客
11-27 872
C++ 注册表的实现 ​ 通常注册表的实现有很多种，这个是基于windows.h 的实现的一种注册表的实现。 源码 // Regedit.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。 // #include <iostream> //#include "stdafx.h" #include"windows.h" #include <tchar.h> #define SIZE 256 int main() { HKEY hKEY; LPCTSTR da
C++注册表操作
sinat_41752325的博客
03-03 4854
1. 基础知识 注册表的组织方式跟文件目录比较相似，主要分为根键、子键和键值项三部分， 1.1 根键 分为5个，分别为： HKEY_CLASSES_ROOT HKEY_CURRENT_USER HKEY_LOCAL_MACHINE HKEY_USERS HKEY_CURRENT_CONFIG 1.2 子键 可以有多个子键和键值项，就像一个目录中可以有多个子目录和多个文件一样。 1.3 键值项 可以理解为......
一个简单的C++注册表操作类
03-15
本文将详细介绍一个简单的C++注册表操作类，以及如何使用此类来实现注册表的读写操作。 首先，让我们了解一下注册表的基本结构。Windows的注册表主要由五大主键（HKEY）组成：HKEY_CLASSES_ROOT、HKEY_CURRENT_USER...
c++ 注册表操作类，操作工程。
05-29
总的来说，这个C++注册表操作类简化了Windows平台上的注册表操作，对于需要与注册表交互的C++程序员来说是一个有价值的工具。通过理解和使用这个类，开发者可以更安全、高效地管理应用程序的配置和系统设置。
C++注册表 编程
12-12
### C++注册表编程知识点详解 #### 一、注册表基础知识 **1. 注册表组织方式** - **根键**: 注册表的核心组成部分，相当于文件系统的根目录，共有五种类型的根键： - **HKEY_CLASSES_ROOT**: 存储关于文件扩展名...
C++操作注册表
07-14
C++虽然不是原生支持注册表操作的语言，但可以通过Windows API函数进行访问。本文将详细介绍如何使用C++来操作注册表，以及如何通过类封装这些操作，并进行调用测试。 1. **注册表结构** Windows注册表主要包含五...
C++编写的注册表完整操作源代码
04-27
C++编写的注册表完整操作源代码,程序所在文件夹名：Do_Reg
C/C++ 操作注册表
fanchx的专栏
11-10 943
#include <iostream.h> #include <Windows.h> #pragma comment(lib, "advapi32.lib" ) int main(int argc, char *argv[]) { HKEY hKey; //要查询的键的句柄 TCHAR *keyName; DWORD dwValue = 0; ...
C++ 读写注册表
LYSM
10-21 604
读注册表 // 初始化 HKEY hKey_return = NULL; // 打开注册表失败 if(ERROR_SUCCESS != RegOpenKeyEx( HKEY_LOCAL_MACHINE, // 注册表根键句柄（也可以是 HKEY_CLASSES_ROOT、HKEY_CURRENT_USER、HKEY_USERS、HKEY_CURRENT_CONFIG） 去...
c++注册表操作
cupidove的专栏
04-30 2028
BOOL fIsBrowser(std::string& paraStrBrowser) {// 判断是否是浏览器 if (std::string::npos != paraStrBrowser.find("Opera")) { paraStrBrowser = "Opera" ; return TRUE ; } else if (std::string::npos != par
C/C++新建注册表项【代码示例】
Python | Golang | C/C++
11-17 6713
使用Windows API 函数中的RegCreateKeyEx函数来实现对注册表新建注册表项。 RegCreateKeyEx函数： 原形：LONGRegCreateKeyEx( HKEYhKey,//主键名称 LPCTSTRlpSubKey,//子键名称或路径 DWORD...
C++写注册表
weixin_30474613的博客
06-23 312
1 #include <iostream> 2 #include <windows.h> 3 using namespace std; 4 5 int main() 6 { 7 HKEY hKEY; 8 HKEY hKEY1; 9 10 char *RegSz = "This is a test!"...
c++写入注册表
weixin_30467087的博客
06-04 218
一、说明： 注册表是Windows重要组成部分，注册表记录了大量有关电脑软硬件的信息。注册表中的值通过其名称标识。值名称由与键名相同的字符组成。值本身可以是字符串、二进制数据或者是32位无符号值。在这里我们主要运用以下技巧： （一）、预定义的注册表键。注册表包含了几个预定义键： HKEY_LOCAL_MACHINE 包含描述计算机及其配置的条目。其中包括关于处理器、系统主板、内...
C++注册表读写dword
最新发布
10-08
在C++中，直接操作Windows注册表（Registry）通常需要借助一些外部库，如Microsoft的WinAPI或是第三方库如Boost Reg等，因为标准库本身并不提供对注册表操作的支持。如果你想读取DWORD类型的值，你可以按照以下步骤： 1. 包含必要的头文件： ```cpp #include <windows.h> #include <tchar.h> ``` 2. 定义函数来打开或关闭注册表键，以及读取DWORD值： ```cpp HKEY hKey; bool OpenRegKey(HKEY& key, const TCHAR* path) { return ::RegOpenKeyEx(HKEY_CURRENT_USER, path, NULL, KEY_READ, &hKey) == ERROR_SUCCESS; } int ReadDWordValue(const TCHAR* keyPath, const TCHAR* valueName) { DWORD dwValue = 0; if (OpenRegKey(hKey, keyPath)) { if (::RegQueryValueEx(hKey, valueName, NULL, NULL, (LPBYTE)&dwValue, NULL) == ERROR_SUCCESS) { ::RegCloseKey(hKey); return dwValue; } ::RegCloseKey(hKey); // 关闭无效的注册表键 } return -1; // 如果出错，返回错误码 } void CloseRegKey() { if (hKey != nullptr) ::RegCloseKey(hKey); } ``` 3. 调用`ReadDWordValue`函数并处理结果： ```cpp int main() { int dwordValue = ReadDWordValue(_T("Software\\YourApp"), _T("YourValue")); if (dwordValue != -1) { // 成功读取，可以做进一步处理 // ... } else { // 处理错误 } CloseRegKey(); // 确保释放资源 return 0; } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值