//========================================================================
//TITLE:
// CReg更新至V1.1.0
//AUTHOR:
// norains
//DATE:
// wednesday 60-June-2007
//Environment:
// EVC4.0 + Standard SDK
//========================================================================
v1.0.0版本及具体用法:http://blog.csdn.net/norains/archive/2007/04/08/1556296.aspx
相对V1.0.0版本的改进:
1.删除难以实现并且容易出问题的两个函数: LPCTSTR GetValueSZ(LPCTSTR szName), LPBYTE GetValueBinary(LPCTSTR szName);
2.修改如下函数的声明:EnumValue,GetValueSZ
3.完善部分函数的说明
4.增加如下函数:GetValueType,CheckKeyExist
5.修正一些已知的bug
///////////////////////////////////////////////////////////////////////
// Reg.h: interface for the CReg class.
//
//Version:
// 1.1.0
//Date:
// 2007.05.28
//////////////////////////////////////////////////////////////////////
#ifndef REG_H
#define REG_H
//---------------------------------------------------------------------
enum ValueType
{
VAL_ERROR,
VAL_DWORD,
VAL_MULTISZ,
VAL_SZ,
VAL_BINARY
};
//---------------------------------------------------------------------
class CReg
{
public:
BOOL CheckKeyExist(HKEY hkRoot,LPCTSTR pszKey);
ValueType GetValueType(LPCTSTR szName);
BOOL DeleteKey(LPCTSTR szName);
BOOL DeleteValue(LPCTSTR szName);
BOOL SetMultiSZ(LPCTSTR szName, LPCTSTR lpszValue, DWORD dwLen);
BOOL SetBinary(LPCTSTR szName, LPBYTE lpbValue, DWORD dwLen);
BOOL SetDW(LPCTSTR szName, DWORD dwValue);
BOOL SetSZ(LPCTSTR szName, LPCTSTR szValue);
BOOL SetSZ(LPCTSTR szName, LPCTSTR szValue, DWORD dwLen);
DWORD GetValueDW(LPCTSTR szName, DWORD dwDefault=0);
DWORD GetValueBinary(LPCTSTR szName, LPBYTE lpbValue, DWORD dwLen);
DWORD GetValueSZ(LPCTSTR szName, LPTSTR szValue, DWORD dwLen);
BOOL EnumValue(LPTSTR pszName, DWORD dwLenName, LPBYTE lpValue, DWORD dwLenValue);
BOOL EnumKey(LPTSTR psz, DWORD dwLen);
BOOL IsOK();
operator HKEY();
void Reset();
CReg(HKEY hkRoot, LPCTSTR pszKey);
BOOL Open(HKEY hkRoot, LPCTSTR pszKey, REGSAM sam=KEY_READ);
BOOL Create(HKEY hkRoot, LPCTSTR pszKey);
CReg();
virtual ~CReg();
private:
HKEY m_hKey;
int m_Index;
LPBYTE m_lpbValue; // last value read, if any
};
#endif //#ifndef REG_H
//////////////////////////////////////////////////////////////////////
// Reg.cpp: implementation of the CReg class.
//
//////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "Reg.h"
//=======================================================================
//Macro define
#define MyFree(p) { if(p) LocalFree(p); }
//=======================================================================
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
//-------------------------------------------------------------------
//Description:
// Construction and open the key
//-------------------------------------------------------------------
CReg::CReg()
{
m_hKey = NULL;
m_Index = 0;
m_lpbValue = NULL;
}
//-------------------------------------------------------------------
//Description:
// Construction and open the key
//
//Parameters:
// hkRoot: [in] The root key
// pszKey: [in] The key to open
//-------------------------------------------------------------------
CReg::CReg(HKEY hkRoot, LPCTSTR pszKey)
{
m_hKey = NULL;
m_Index = 0;
m_lpbValue = NULL;
Open(hkRoot, pszKey);
}
//-------------------------------------------------------------------
//Description:
// Destruction
//-------------------------------------------------------------------
CReg::~CReg()
{
if(m_hKey)
{
RegCloseKey(m_hKey);
}
MyFree(m_lpbValue);
}
//-------------------------------------------------------------------
//Description:
// This function creates the specified key.
//If the key already exists in the registry, the function opens it.
//After succeed in calling the fuction,should call the Reset() to release the resource.
//
//Parameters:
// hkRoot: [in] The root key
// pszKey: [in] The key to create
//-------------------------------------------------------------------
BOOL CReg::Create(HKEY hkRoot, LPCTSTR pszKey)
{
DWORD dwDisp;
return ERROR_SUCCESS == RegCreateKeyEx(hkRoot, pszKey, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &m_hKey, &dwDisp);
}
//-------------------------------------------------------------------
//Description:
// This function opens the specified key.
//After succeed in calling the fuction,should call the Reset() to release the resource.
//
//Parameters:
// hkRoot: [in] The root key
// pszKey: [in] The key to open
// sam: [in] Not supported; set to 0
//-------------------------------------------------------------------
BOOL CReg::Open(HKEY hkRoot, LPCTSTR pszKey, REGSAM sam)
{
return ERROR_SUCCESS == RegOpenKeyEx(hkRoot, pszKey, 0, sam, &m_hKey);
}
//-------------------------------------------------------------------
//Description:
// Reset the value and release the resource.
//-------------------------------------------------------------------
void CReg::Reset()
{
if(m_hKey)
{
RegCloseKey(m_hKey);
}
MyFree(m_lpbValue);
m_hKey = NULL;
m_Index = 0;
m_lpbValue = NULL;
}
//-------------------------------------------------------------------
//Description:
// Operator overload
//-------------------------------------------------------------------
CReg::operator HKEY()
{
return m_hKey;
}
//-------------------------------------------------------------------
//Description:
// Check whether is ready for next operate
//
//Return value:
// TRUE : Ready to do next operate
// FALSE: Not ready.
//-------------------------------------------------------------------
BOOL CReg::IsOK()
{
return m_hKey != NULL;
}
//-------------------------------------------------------------------
//Description:
// This function enumerates subkeys of the specified open registry key.
//
//Parameters:
// psz: [out] Pointer to a buffer that receives the name of the subkey, including the terminating null character.
// The function copies only the name of the subkey, not the full key hierarchy, to the buffer.
// dwLen: [in] Specifies the length of the buffer pointed to by the psz parameter.
//-------------------------------------------------------------------
BOOL CReg::EnumKey(LPTSTR psz, DWORD dwLen)
{
if(!m_hKey)
{
return FALSE;
}
dwLen *= sizeof(TCHAR);
return ERROR_SUCCESS == RegEnumKeyEx(m_hKey, m_Index++, psz, &dwLen, NULL, NULL, NULL, NULL);
}
//-------------------------------------------------------------------
//Description:
// This function enumerates the values for the specified open registry key.
//
//Parameters:
// pszName: [out] Pointer to a buffer that receives the name of the value, including the terminating null character.
// dwLenName: [in] Specifies the length of the buffer pointed to by the pszName parameter.
// lpValue: [out] Pointer to a buffer that receives the data for the value entry. This parameter can be NULL if the data is not required.
// dwLenValue: [in] Specifies the length of the buffer pointed to by the lpValue parameter.
//-------------------------------------------------------------------
BOOL CReg::EnumValue(LPTSTR pszName, DWORD dwLenName, LPBYTE lpValue, DWORD dwLenValue)
{
DWORD dwType;
if(!m_hKey)
{
return FALSE;
}
dwLenValue *= sizeof(BYTE); // convert length in number to bytes
return ERROR_SUCCESS == RegEnumValue(m_hKey, m_Index++, pszName, &dwLenName, NULL, &dwType, (LPBYTE)lpValue, &dwLenValue);
}
//--------------------------------------------------------------------------------------------------------------
//Description:
// Get the string value
//
//Parameters:
// szName: [in] Pointer to a string containing the name of the value to query
// szValue: [out] Pointer to a buffer that receives the value's data.
// If it's null, it will return the size of buffer need.
// dwLen: [in] Specifies the length of the buffer pointed to by the szValue parameter.
// If szValue is null, the parameter would ignore.
//
//Return value:
// The number of the characters have been get.
//0 means failed. Others means succeed, and the value include the null character
//----------------------------------------------------------------------------------------------------------------------
DWORD CReg::GetValueSZ(LPCTSTR szName, LPTSTR szValue, DWORD dwLen)
{
if(!m_hKey)
{
return FALSE;
}
dwLen *= sizeof(TCHAR); // convert length in chars to bytes
DWORD dwType ;
if(ERROR_SUCCESS == RegQueryValueEx(m_hKey, szName, NULL, &dwType, (LPBYTE)szValue, &dwLen))
{
if(REG_SZ != dwType)
{
dwLen = 0;
return FALSE;
}
else
{
dwLen /= sizeof(TCHAR);
}
}
else
{
dwLen = 0;
}
return dwLen;
}
//-------------------------------------------------------------------
//Description:
// Get the binary value
//
//Parameters:
// szName: [in] Pointer to a string containing the name of the value to query
// lpbValue: [out] Pointer to a buffer that receives the value's data.
// If it's null, it will return the size of buffer need.
// dwLen: [in] Specifies the length of the buffer pointed to by the lpbValue parameter.
// If szValue is null, the parameter would ignore.
//
//Return value:
// The number of the binary have been get.
//0 means failed. Others means succeed, and the value include the null character
//-------------------------------------------------------------------
DWORD CReg::GetValueBinary(LPCTSTR szName, LPBYTE lpbValue, DWORD dwLen)
{
if(!m_hKey)
{
return FALSE;
}
DWORD dwType ;
if(ERROR_SUCCESS == RegQueryValueEx(m_hKey, szName, NULL, &dwType, lpbValue, &dwLen))
{
if(dwType != REG_BINARY)
{
dwLen = 0;
}
}
else
{
dwLen = 0;
}
return dwLen;
}
//-------------------------------------------------------------------
//Description:
// Get the DWORD value
//
//Parameters:
// szName:[in] The value of registry
// dwDefault:[in] The default value return when failed in getting the DWORD value.
//
//Return value:
// If the return value just be same as the dwDefault, it may mean failed.
//-------------------------------------------------------------------
DWORD CReg::GetValueDW(LPCTSTR szName, DWORD dwDefault)
{
if(!m_hKey)
{
return FALSE;
}
DWORD dwValue = dwDefault;
DWORD dwLen = sizeof(DWORD);
DWORD dwType;
if(ERROR_SUCCESS == RegQueryValueEx(m_hKey, szName, NULL, &dwType, (LPBYTE)&dwValue, &dwLen))
{
if(dwType != REG_DWORD)
{
dwValue = dwDefault;
}
}
else
{
dwValue = dwDefault;
}
return dwValue;
}
//-------------------------------------------------------------------
//Description:
// Set the string value
//
//Parameters:
// szName: [in] Pointer to a string containing the name of the value to set
// szValue: [in] The buffer include the data to be set
// dwLen: [in] Specifies the length of the buffer pointed to by the szValue parameter.
//-------------------------------------------------------------------
BOOL CReg::SetSZ(LPCTSTR szName, LPCTSTR szValue, DWORD dwLen)
{
//Prefix
if(!m_hKey)
{
return FALSE;
}
return ERROR_SUCCESS == RegSetValueEx(m_hKey, szName, 0, REG_SZ, (LPBYTE)szValue, sizeof(TCHAR)*dwLen);
}
//-------------------------------------------------------------------
//Description:
// Set the string value
//
//Parameters:
// szName: [in] Pointer to a string containing the name of the value to set
// szValue: [in] The string buffer include null character to be set
//-------------------------------------------------------------------
BOOL CReg::SetSZ(LPCTSTR szName, LPCTSTR szValue)
{
return SetSZ(szName, szValue, 1 + _tcslen(szValue));
}
//-------------------------------------------------------------------
//Description:
// Get the DWORD value
//
//Parameters:
// szName: [in] Pointer to a string containing the name of the value to set
// dwValue: [in] The value to be set
//-------------------------------------------------------------------
BOOL CReg::SetDW(LPCTSTR szName, DWORD dwValue)
{
//Prefix
if(!m_hKey)
{
return FALSE;
}
return ERROR_SUCCESS==RegSetValueEx(m_hKey, szName, 0, REG_DWORD, (LPBYTE)&dwValue, sizeof(DWORD));
}
//-------------------------------------------------------------------
//Description:
// Get the binary value
//
//Parameters:
// szName: [in] Pointer to a string containing the name of the value to set
// lpbValue: [in] The buffer include the data to be set
// dwLen: [in] Specifies the length of the buffer pointed to by the lpbValue parameter.
//-------------------------------------------------------------------
BOOL CReg::SetBinary(LPCTSTR szName, LPBYTE lpbValue, DWORD dwLen)
{
//Prefix
if(!m_hKey)
{
return FALSE;
}
return ERROR_SUCCESS == RegSetValueEx(m_hKey, szName, 0, REG_BINARY, lpbValue, sizeof(BYTE) * dwLen);
}
//-------------------------------------------------------------------
//Description:
// Set the Multi value
//
//Parameters:
// szName: [in] Pointer to a string containing the name of the value to set
// lpszValue: [in] The buffer include the data to be set
// dwLen: [in] Specifies the length of the buffer pointed to by the lpszValue parameter.
//-------------------------------------------------------------------
BOOL CReg::SetMultiSZ(LPCTSTR szName, LPCTSTR lpszValue, DWORD dwLen)
{
return ERROR_SUCCESS == RegSetValueEx(m_hKey, szName, 0, REG_MULTI_SZ, (LPBYTE)lpszValue, sizeof(TCHAR)*dwLen);
}
//-------------------------------------------------------------------
//Description:
// This function removes a named value from the specified registry key.
//
//Parameters:
// szName:[in] Pointer to a null-terminated string that names the value to remove.
//-------------------------------------------------------------------
BOOL CReg::DeleteValue(LPCTSTR szName)
{
//Prefix
if(!m_hKey)
{
return FALSE;
}
//
return ERROR_SUCCESS == RegDeleteValue(m_hKey, szName);
}
//-------------------------------------------------------------------
//Description:
// This function recursively deletes all subkeys of a named subkey of a specified registry key.
//
//Parameters:
// szName:[in] Pointer to a null-terminated string specifying the name of the key to delete. This parameter cannot be NULL.
//-------------------------------------------------------------------
BOOL CReg::DeleteKey(LPCTSTR szName)
{
if(!m_hKey)
{
return FALSE;
}
return ERROR_SUCCESS == RegDeleteKey(m_hKey, szName);
}
//-------------------------------------------------------------------
//Description:
// Get the value type
//
//Parameters:
// szName: [in] Pointer to a null-terminated string that names the value
//
//------------------------------------------------------------------------
ValueType CReg::GetValueType(LPCTSTR szName)
{
if(m_hKey == NULL)
{
return VAL_ERROR;
}
DWORD dwType ;
if(ERROR_SUCCESS != RegQueryValueEx(m_hKey, szName, NULL, &dwType, 0, 0))
{
return VAL_ERROR;
}
switch(dwType)
{
case REG_BINARY:
return VAL_BINARY;
case REG_DWORD:
case REG_DWORD_BIG_ENDIAN:
return VAL_DWORD;
case REG_EXPAND_SZ:
case REG_SZ:
return VAL_SZ;
case REG_MULTI_SZ:
return VAL_MULTISZ;
default:
return VAL_ERROR; // There are other types, but not supported by CReg
}
}
//-------------------------------------------------------------------
//Description:
// Check the key exist.
//
//Parameters:
// pszKey: [in] Pointer to a null-terminated string that names key
//
//------------------------------------------------------------------------
BOOL CReg::CheckKeyExist(HKEY hkRoot,LPCTSTR pszKey)
{
HKEY hKey = 0;
if(ERROR_SUCCESS == RegOpenKeyEx(hkRoot, pszKey, 0, 0, &hKey))
{
RegCloseKey(hKey);
return TRUE;
}
else
{
return FALSE;
}
}
发表于 @ 2007年06月20日 21:05:00|评论(loading...)|编辑