实用注册表管理类

#pragma once

class Registry
{
public:
	Registry(HKEY root, const std::wstring& path);
	~Registry();
	bool Create();
	bool CreateKey(const std::wstring& subKey);
	std::wstring QueryValue(const std::wstring& key);
	DWORD QuerydwordValue(const std::wstring& key);
	bool SetValue(const std::wstring& key, const std::wstring& value);
	bool SetdwordValue(const std::wstring& key, DWORD value);
	bool DeleteKey(const std::wstring& key);
	bool DeleteValue(const std::wstring& key);
	bool Delete();

private:
	HKEY			root_;
	std::wstring	path_;
	HKEY			hkey_;
};

#include "StdAfx.h"
#include "registry.h"

Registry::Registry(HKEY root, const std::wstring& path)
	: hkey_(NULL), root_(root), path_(path) {}

Registry::~Registry() {}

bool Registry::Create()
{
	DWORD dwState = 0;
	LONG lRet = ::RegCreateKeyEx(root_, path_.c_str(), 0, NULL, 0, KEY_ALL_ACCESS, NULL, &hkey_, &dwState);
	if(lRet == ERROR_SUCCESS) {
		::RegCloseKey(hkey_);
	}
	return (lRet == ERROR_SUCCESS);
}

bool Registry::CreateKey(const std::wstring& subKey)
{
	DWORD dwState = 0;
	LONG lRet = ::RegCreateKeyEx(root_, path_.c_str(), 0, NULL, 0, 0, NULL, &hkey_, &dwState);
	if(lRet == ERROR_SUCCESS) {
		::RegCloseKey(hkey_);
	}
	return (lRet == ERROR_SUCCESS);
}

std::wstring Registry::QueryValue(const std::wstring& key)
{
	LONG lRet = ::RegOpenKeyEx(root_, path_.c_str(), 0, KEY_READ, &hkey_);
	TCHAR tszVal[MAX_PATH] = { 0 };
	if (lRet == ERROR_SUCCESS) {
		DWORD dwType, dwSize;
		dwSize = sizeof (tszVal);
		::RegQueryValueEx(hkey_, key.c_str(), 0, &dwType, (LPBYTE)tszVal, &dwSize);
		::RegCloseKey(hkey_);
	}
	return tszVal;
}

DWORD Registry::QuerydwordValue(const std::wstring& key)
{
	DWORD dwValue = 0, dwType = 0, dwSize = sizeof(DWORD);
	LONG lRet = ::RegOpenKeyEx(root_, path_.c_str(), 0, KEY_READ, &hkey_);
	if (lRet == ERROR_SUCCESS) {
		::RegQueryValueEx(hkey_, key.c_str(), NULL, &dwType, reinterpret_cast<LPBYTE>(&dwValue), &dwSize);
		::RegCloseKey(hkey_);
	}
	return dwValue;
}

bool Registry::SetValue(const std::wstring& key, const std::wstring& value)
{
	LONG lRet = ::RegOpenKeyEx(root_, path_.c_str(), 0, KEY_WRITE, &hkey_);
	if (lRet == ERROR_SUCCESS) {
		lRet = ::RegSetValueEx(hkey_, key.c_str(), 0, REG_SZ, (LPBYTE)value.c_str(), sizeof(TCHAR) * value.size());
		::RegCloseKey(hkey_);
	}
	return (lRet == ERROR_SUCCESS);
}

bool Registry::SetdwordValue(const std::wstring& key, DWORD value)
{
	LONG lRet = ::RegOpenKeyEx(root_, path_.c_str(), 0, KEY_WRITE, &hkey_);
	if (lRet == ERROR_SUCCESS) {
		lRet = ::RegSetValueEx(hkey_, key.c_str(), 0, REG_DWORD, (LPBYTE)&value, sizeof(DWORD));
		::RegCloseKey(hkey_);
	}
	return (lRet == ERROR_SUCCESS);
}

bool Registry::DeleteKey(const std::wstring& key)
{
	return (::RegDeleteKey(root_, key.c_str()) == ERROR_SUCCESS);
}

bool Registry::DeleteValue(const std::wstring& key)
{
	LONG lRet = ::RegOpenKeyEx(root_, path_.c_str(), 0, KEY_WRITE, &hkey_);
	if (lRet == ERROR_SUCCESS) {
		lRet = ::RegDeleteValue(hkey_, key.c_str());
		::RegCloseKey(hkey_);
	}
	return (lRet == ERROR_SUCCESS);
}

bool Registry::Delete()
{
	return (::RegDeleteKey(root_, path_.c_str()) == ERROR_SUCCESS);
}