CReg更新至V1.1.0

//========================================================================
//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;
    }


    
}
评论 7
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值