📄 myreg.cpp

📁 电子监控的网络编程实例
💻 CPP
字号:
//CReg类定义文件
/********************************************************************************
//解析INI文件
// Written by: YiJian Feng
// Email: netfyee@hotmail.com
// Last Edit: 2003-5-5 

---使用
首先必须设置
BOOL SetFileName(CString FileName);
BOOL SetSectionName(CString SectionName);

**********************************************************************************/

//////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "MyReg.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CReg::CReg()
{
	m_hRegKey = (HKEY)0;
	SetMyRegRootKey();
	m_strSubKey = NULL;	

	m_strErrorDec = new TCHAR[MAX_PATH];
}

CReg::~CReg()
{
	CloseMyReg();

	delete m_strErrorDec;
}

//////////////////////////////////////////////////////////////////////
// Member Function
//////////////////////////////////////////////////////////////////////

long CReg::CreateMyReg(LPCTSTR lpSubKey,	BOOL IsOnlyRead)
{
	long eRegErr;

	CloseMyReg();

	eRegErr = SetMyRegSubKeyString(lpSubKey); 
	if (REG_NO_ERROR != eRegErr)
		return eRegErr;
	
	//打开注册表的状态
	if (!IsOnlyRead)
	{
		DWORD dwDisposition;
		if(ERROR_SUCCESS != RegCreateKeyEx(m_hRegRootKey, 
																				m_strSubKey, 
																				0, 
																				NULL, 
																				REG_OPTION_NON_VOLATILE, 
																				KEY_ALL_ACCESS,
																				NULL, 
																				&m_hRegKey,
																				&dwDisposition))
			eRegErr = REG_BAD_CREATE;
	}
	else
	{
		if (ERROR_SUCCESS != RegOpenKeyEx(m_hRegRootKey,
																			m_strSubKey,
																			0,
																			KEY_ALL_ACCESS,
																			&m_hRegKey))
			eRegErr = REG_BAD_CREATE;
	}

	return eRegErr;
}

long CReg::CloseMyReg()
{
	long eRegErr = REG_NO_ERROR;

	//关闭注册表句柄
	if ((HKEY)0 < m_hRegKey)
	{
		if (ERROR_SUCCESS != RegCloseKey(m_hRegKey))
			eRegErr = REG_BAD_CLOSE;
		m_hRegKey = (HKEY)0;
	}

	//释放子键字符串缓存
	if (NULL != m_strSubKey)
	{
		delete [] m_strSubKey;	
		m_strSubKey = NULL;
	}

	return eRegErr;
}


void CReg::SetMyRegRootKey(HKEY lpRootKey)
{
	m_hRegRootKey = lpRootKey;	
}


long CReg::SetMyRegSubKeyString(LPCTSTR lpSubKey)
{
	if (m_strSubKey)
		delete [] m_strSubKey;

	int nSubKeySize = lstrlen(lpSubKey);

	if (0 == nSubKeySize)
		return REG_INVALID_SUBKEY;

	//判断第一个字符是否为"\",因为子键第一个字符不能为反斜杠
	LPCTSTR lpNextPoint = "";
	if (__TEXT('\\') == *lpSubKey)
	{
		lpNextPoint = CharNext(lpSubKey);
		--nSubKeySize;
	}
	else
		lpNextPoint = lpSubKey;
	
	m_strSubKey = new TCHAR[nSubKeySize + 1];	//lstrlen求得的长
																					//度不包括终止符“NULL”
	lstrcpy(m_strSubKey, lpSubKey);

	return REG_NO_ERROR;
}


long CReg::GetMyRegValueAttribute(LPCTSTR lpValueName, 
																				LPDWORD lpType, 
																				LPDWORD lpcbData)
{
	if ((HKEY)0 == m_hRegKey)
		return REG_NOT_INITIALIZE;

	if (ERROR_SUCCESS != RegQueryValueEx(m_hRegKey,
																				lpValueName,
																				NULL,
																				lpType,
																				NULL,
																				lpcbData))
		return REG_FAIL_READATTRIBUTE;

	return REG_NO_ERROR;
}


long CReg::GetMyRegValueAttribute(LPCTSTR lpSubKeyName, 
																				 LPCTSTR lpValueName, 
																				 LPDWORD lpType, 
																				 LPDWORD lpcbData)
{
	long eRegErr = CreateMyReg(lpSubKeyName, TRUE);

	if (REG_NO_ERROR != eRegErr)
		return eRegErr;

	eRegErr = GetMyRegValueAttribute(lpValueName, lpType, lpcbData);

	return eRegErr;
}


long CReg::GetMyRegValue(LPCTSTR	lpValueName, LPBYTE	lpData)
{
	long eRegErr = GetMyRegValueEx(lpValueName, REG_NONE, lpData);	
	
	return eRegErr;	
}


long CReg::GetMyRegValue(LPCTSTR	lpSubKeyName,
																LPCTSTR	lpValueName,
																LPBYTE	lpData)
{
	long eRegErr = GetMyRegValueEx(lpSubKeyName, 
																	lpValueName, 
																	REG_NONE,
																	lpData);

	
	return eRegErr;	
}


long CReg::GetMyRegValue(LPCTSTR lpValueName, 
																LPTSTR lpData, 
																LPCTSTR lpDefData)
{
	DWORD dwDataLength = MAX_PATH;

	if (ERROR_SUCCESS != RegQueryValueEx(m_hRegKey, 
																				lpValueName,
																				NULL,
																				NULL,
																				reinterpret_cast<BYTE*>(lpData),
																				&dwDataLength))					
	{
		lstrcpy(lpData, lpDefData);
	}

	return 0;	
};	


long CReg::SetMyRegValue(LPCTSTR			lpValueName, 
																LPCTSTR			lpData)
{
  if (ERROR_SUCCESS != RegSetValueEx(m_hRegKey,
																			lpValueName,
																			NULL,
																			REG_SZ,
																			reinterpret_cast<const BYTE*>(lpData),
																			lstrlen(lpData)))
	{
		return REG_FAIL_WRITEKEYVALUE;	
	}

	return REG_NO_ERROR;
}


long CReg::GetMyRegValue(LPCTSTR lpSubKeyName, 
																LPCTSTR lpValueName, 
																LPTSTR lpData)
{
	long eRegErr = GetMyRegValueEx(lpSubKeyName,
																	lpValueName, 
																	REG_SZ,
																	reinterpret_cast<LPBYTE>(lpData));
	
	return eRegErr;	
}


long CReg::GetMyRegValue(LPCTSTR lpValueName, 
																LPDWORD lpData,
																const DWORD	dwDefData)
{
	DWORD dwDataLength = MAX_PATH;

	if (ERROR_SUCCESS != RegQueryValueEx(m_hRegKey, 
																				lpValueName,
																				NULL,
																				NULL,
																				reinterpret_cast<BYTE*>(lpData),
																				&dwDataLength))					
	{
		*lpData = dwDefData;
	}

	return 0;	
}



long CReg::SetMyRegValue(LPCTSTR			lpValueName, 
																const DWORD	lData)
{
	int nData[256];

	nData[0] = lData;
  if (ERROR_SUCCESS != RegSetValueEx(m_hRegKey,
																			lpValueName,
																			NULL,
																			REG_DWORD,
																			(const unsigned char *)nData,
																			4))
	{
		return REG_FAIL_WRITEKEYVALUE;	
	}

	return REG_NO_ERROR;
}


long CReg::GetMyRegValue(LPCTSTR lpSubKeyName, 
																LPCTSTR lpValueName,
																LPDWORD lpData)
{
	long eRegErr = GetMyRegValueEx(lpSubKeyName,
																	lpValueName, 
																	REG_DWORD,
																	reinterpret_cast<LPBYTE>(lpData));

	
	return eRegErr;	
}

long CReg::GetMyRegValueEx(LPCTSTR				lpValueName,
																	const DWORD   cbType,
																	LPBYTE				lpData)
{
	DWORD dType;
	DWORD dcbData;

	long eRegErr = GetMyRegValueAttribute(lpValueName, &dType, &dcbData);
	
	if (REG_NO_ERROR != eRegErr)
		return eRegErr;

	if ((REG_NONE != cbType) && (cbType != dType))
		return REG_ERROR_KEYTYPE;

	++dcbData;
  if (ERROR_SUCCESS != RegQueryValueEx(m_hRegKey,
																				lpValueName,
																				NULL,
																				NULL,
																				lpData,
																				&dcbData))
	{
		return REG_FAIL_READKEYVALUE;	
	}

	return REG_NO_ERROR;
}


long CReg::GetMyRegValueEx(LPCTSTR				lpSubKeyName, 
																	LPCTSTR				lpValueName,
																	const DWORD		cdType,
																	LPBYTE				lpData)
{
	long eRegErr = CreateMyReg(lpSubKeyName, TRUE);

	if (REG_NO_ERROR != eRegErr)
		return eRegErr;

	eRegErr = GetMyRegValueEx(lpValueName, cdType, lpData);

	return REG_NO_ERROR;
}



long CReg::DelMyRegValue(LPCTSTR lpValueName)
{
  if (ERROR_SUCCESS != RegDeleteValue(m_hRegKey,
																			lpValueName))
	{
		return REG_FAIL_DELKEYVALUE;	
	}

	return REG_NO_ERROR;
}


long CReg::DelMyRegValue(LPCTSTR lpSubKeyName, LPCTSTR lpValueName)
{
	long eRegErr = CreateMyReg(lpSubKeyName, TRUE);

	if (REG_NO_ERROR != eRegErr)
		return eRegErr;

	eRegErr = DelMyRegValue(lpValueName);

	return REG_NO_ERROR;
}


long CReg::DelMyRegSubKey(LPCTSTR lpDelSubKeyName)
{
  if (ERROR_SUCCESS != RegDeleteKey(m_hRegKey, lpDelSubKeyName))
	{
		return REG_FAIL_DELSUBKEY;	
	}

	return REG_NO_ERROR;
}


long CReg::DelMyRegSubKey(LPCTSTR lpSubKeyName, LPCTSTR lpDelSubKeyName)
{
	long eRegErr = CreateMyReg(lpSubKeyName, TRUE);

	if (REG_NO_ERROR != eRegErr)
		return eRegErr;

	eRegErr = DelMyRegSubKey(lpDelSubKeyName);

	return REG_NO_ERROR;
}


long CReg::GetMyRegSubKeysCount(LPDWORD lpcbSubKeys, LPDWORD lpSubValue)
{
	if (ERROR_SUCCESS != RegQueryInfoKey(m_hRegKey,
		NULL,
		NULL,
		NULL,
		lpcbSubKeys,
		NULL,
		NULL,
		lpSubValue,
		NULL,
		NULL,
		NULL,
		NULL))
	{
		return REG_FAIL_DELSUBKEY;	
	}

	return REG_NO_ERROR;
}


long CReg::GetMyRegSubKeysCount(LPCTSTR lpSubKeyName, LPDWORD lpcbSubKeys, LPDWORD lpSubValue)

{
	long eRegErr = CreateMyReg(lpSubKeyName, TRUE);

	if (REG_NO_ERROR != eRegErr)
		return eRegErr;

	eRegErr = GetMyRegSubKeysCount(lpcbSubKeys, lpSubValue);

	return REG_NO_ERROR;
}

long CReg::EnumMyRegSubKeys(DWORD  dwIndex, LPTSTR	lpName)
{
  DWORD dwcbName = MAX_PATH;
	long eRegErr = RegEnumKeyEx(m_hRegKey, dwIndex, lpName, &dwcbName,
															NULL, NULL, NULL, NULL);

	if (ERROR_NO_MORE_ITEMS == eRegErr)
		return REG_NO_MORE_ITEMS;
	else if (ERROR_SUCCESS != eRegErr)
		return RET_FAIL_ENUM_SUBKEY;

	return REG_NO_ERROR;
}

LPCTSTR CReg::GetMyRegErrMsg(const long lErrorIndex) const
{
	switch (lErrorIndex)
	{
		case REG_NO_ERROR:
			lstrcpy(m_strErrorDec, _T("没有错误！"));
			break;
		case REG_BAD_CREATE:
			lstrcpy(m_strErrorDec, _T("打开注册表错误！"));
			break;
		case REG_NOT_INITIALIZE:
			lstrcpy(m_strErrorDec, _T("没有初始化！"));
			break;
		case REG_BAD_CLOSE:
			lstrcpy(m_strErrorDec, _T("关闭注册表错误！"));
			break;
		case REG_INVALID_SUBKEY:
			lstrcpy(m_strErrorDec, _T("无效的子键！"));
			break;
		case REG_FAIL_READATTRIBUTE:
			lstrcpy(m_strErrorDec, _T("读取键值属性失败！"));
			break;
		case REG_FAIL_READKEYVALUE:
			lstrcpy(m_strErrorDec, _T("读取键值失败！"));
			break;
		case REG_ERROR_KEYTYPE:
			lstrcpy(m_strErrorDec, _T("错误的键类型"));
			break;
		case REG_BAD_ALLOC:
			lstrcpy(m_strErrorDec, _T("分配内存失败！"));
			break;
		case REG_NO_ENOUGH_BUFFER:
			lstrcpy(m_strErrorDec, _T("给定的缓存太小！"));
			break;
		case REG_FAIL_WRITEKEYVALUE:
			lstrcpy(m_strErrorDec, _T("写入键值失败！"));
			break;
		case REG_FAIL_DELKEYVALUE:
			lstrcpy(m_strErrorDec, _T("删除键值失败！"));
			break;			
		case REG_FAIL_DELSUBKEY:
			lstrcpy(m_strErrorDec, _T("删除子键失败！"));
			break;			
		case RET_FAIL_ENUM_SUBKEY:
			lstrcpy(m_strErrorDec, _T("列举子键失败！"));
			break;			
		case REG_NO_MORE_ITEMS:
			lstrcpy(m_strErrorDec, _T("列举子键结束！"));
			break;			
		default:
			lstrcpy(m_strErrorDec, _T("未知的错误类型！"));
			break;
	}

	return m_strErrorDec;
}

long CReg::EnumMyRegSubKeyValues(DWORD dwIndex, LPTSTR lpName, LPTSTR lpValue)
{
	DWORD dwcbName = MAX_PATH;
	DWORD type_1=REG_SZ;
	DWORD cbData_1=20;
	long eRegErr = ::RegEnumValue(m_hRegKey, dwIndex, lpName, &dwcbName , NULL, &type_1,(BYTE*)lpValue,&cbData_1);
	if (ERROR_NO_MORE_ITEMS == eRegErr)
		return REG_NO_MORE_ITEMS;
	else if (ERROR_SUCCESS != eRegErr)
		return RET_FAIL_ENUM_SUBKEY;
	
	return REG_NO_ERROR;
}
💿 文件大小 1506 K
👤 上传用户 zln12345
📂 所属分类通讯/手机编程
🏷️ 相关标签

#电子监控 #网络 #编程实例
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -