那位有写注册表的例程？（VC）急。。。

Question

我现在需要向注册表中写几条ODBC的驱动位置，哪位高手可以给我一个这方面的例程，不胜感谢！！！

Answer 1

一个简单的读写注册表实例
http://www.vckbase.com/document/viewdoc.asp?id=442

Answer 2

我看了，可是RegCreateKeyEx（）的参数怎么设呢？我需要更多的例程，多谢！

Answer 3

VC＋＋：访问和修改系统注册表  
　　Windows95／98的注册表包含了Windows95／98的系统配置、PC机的硬件配置
、Win32应用程序和用户的其他设置信息。注册表和INI文件不同，它是多层次的
树状数据结构，具有六个分支（根键），每个分支又由许多的键和键值组成，而
每个键则代表一个特定的配置项目。 　　在实际的编程工作中，我们遇到了如何在Visual C＋＋中对Windows95／98注
册表整个树状结构信息进行访问和修改的问题，如查询和修改注册表中用户姓名
和公司名称的有关信息。通过编程实践，我们实现了在Visual C＋＋中查询和修
改系统注册表的有关信息。下面以一个实例说明具体的编程方法。 　　在Visual C＋＋ 6.0或5.0环境中新建一基于对话框的工程，设置了两个命令
按钮，名为“查询用户信息”和“修改用户信息”，用来查询和修改注册表中用
户姓名和公司名称。这里须要指出的是，用户的信息位于系统注册表中 
HKEY_LOCAL_MACHINE Software Microsoft Windows CurrentVersion 的位置，键
值名RegisteredOwner和RegisteredOrganization分别表示用户的姓名和用户公司
的名称。 　　1.查询用户信息的代码 
　　HKEY hKEY; ／／定义有关的 hKEY, 在查询结束时要关闭。 
　　LPCTSTR data_Set=″Software\Microsoft\Windows\CurrentVersion\″; 
　　／／打开与路径 data_Set 相关的 hKEY，第一个参数为根键名称，第二个参数表。 
　　／／表示要访问的键的位置，第三个参数必须为0，KEY_READ表示以查询的方式。 
　　／／访问注册表，hKEY则保存此函数所打开的键的句柄。 
　　long ret0=(::RegOpenKeyEx(HKEY_LOCAL_MACHINE,data_Set, 0, KEY_READ, ＆hKEY)); 
　　if(ret0!=ERROR_SUCCESS) ／／如果无法打开hKEY，则终止程序的执行 
　　{MessageBox(″错误: 无法打开有关的hKEY!″); 
　　return;} 
　　／／查询有关的数据 (用户姓名 owner_Get)。 
　　LPBYTE owner_Get=new BYTE［80］; 
　　DWORD type_1=REG_SZ ; DWORD cbData_1=80; 
　　／／hKEY为刚才RegOpenKeyEx()函数所打开的键的句柄，″RegisteredOwner″。 
　　／／表示要查 询的键值名，type_1表示查询数据的类型，owner_Get保存所。 
　　／／查询的数据，cbData_1表示预设置的数据长度。 
long ret1=::RegQueryValueEx(hKEY, ″RegisteredOwner″, NULL, 
　　＆type_1, owner_Get, ＆cbData_1); 
　　if(ret1!=ERROR_SUCCESS) 
　　{ 
　　MessageBox(″错误: 无法查询有关注册表信息!″); 
　　return; 
　　} 
　　／／ 查询有关的数据 (公司名 company_Get) 
　　LPBYTE company_Get=new BYTE ［80］; 
　　DWORD type_2=REG_SZ; DWORD cbData_2=80; 
　　long ret2=::RegQueryValueEx(hKEY, ″RegisteredOrganization″, NULL,＆type_2,company_Get, ＆cbData_2); 
　　if(ret2!=ERROR_SUCCESS) 
　　{ 
　　MessageBox(″错误: 无法查询有关注册表信息!″); 
　　return; 
　　 } 
　　／／ 将 owner_Get 和 company_Get 转换为 CString 字符串, 以便显示输出。 
　　CString str_owner=CString(owner_Get); 
　　CString str_company=CString(company_Get); 
　　delete［］ owner_Get; delete［］ company_Get; 
　　／／ 程序结束前要关闭已经打开的 hKEY。 
　　::RegCloseKey(hKEY); 
　　…… 　　这样，上述程序执行完毕，字符串str_owner和str_company则表示查询到的
用户的姓名和公司的名称，在VC＋＋中便可用对话框的方式将其显示出来。 　　2． 修改用户信息的代码（注意和上述的查询代码属于不同的函数体） 　　在程序中我们先显示一个对话框，要求用户输入新的用户姓名和公司名称并
按确认键，将取得CString类型的有关字符串。要先将其转换为LPBYTE（即
unsigned char＊）型的数据类型，以便后面的函数调用。下面是程序中用到的将
CString型转换为LPBYTE的转换函数： 
　　LPBYTE CString_To_LPBYTE(CString str) 
　　{ 
　　LPBYTE lpb=new BYTE［str.GetLength()＋1］; 
　　<str.GetLength(); i＋＋)lpb［i］=str［i］;> 
　　for(int i=0; ibr> 　　lpb［str.GetLength()］=0; 
　　return lpb; 
　　} 
　　以下则是具体的修改注册表用户信息的代码： 
　　CString str_owner, str_company; 
　　…… ／／通过对话框输入新的用户信息，保存到str_owner和str_company 
　　／／定义有关的 hKEY, 在程序的最后要关闭。 
HKEY hKEY; 
　　LPCTSTR data_Set=″Software\Microsoft\Windows\CurrentVersion″; 
　　／／打开与路径 data_Set 相关的hKEY，KEY_WRITE表示以写的方式打开。 
　　long ret0=(::RegOpenKeyEx(HKEY_LOCAL_MACHINE, 
　　data_Set, 0, KEY_WRITE, ＆hKEY)); 
　　if(ret0!=ERROR_SUCCESS) 
　　{ 
　　MessageBox(″错误: 无法打开有关的hKEY!″); 
　　return; 
　　} 
　　／／修改有关数据(用户姓名 owner_Set)，要先将CString型转换为LPBYTE。 
　　LPBYTE owner_Set=CString_To_LPBYTE(str_owner); 
　　DWORD type_1=REG_SZ; 
　　DWORD cbData_1=str_owner.GetLength()＋1; 
　　／／与RegQureyValueEx()类似，hKEY表示已打开的键的句柄，″RegisteredOwner″ 
　　／／表示要访问的键值名，owner_Set表示新的键值，type_1和cbData_1表示新值。 
　　／／的数据类型和数据长度 
　　long ret1=::RegSetValueEx(hKEY, ″RegisteredOwner″, NULL, 
　　type_1, owner_Set, cbData_1); 
　　if(ret1!=ERROR_SUCCESS) 
　　{ 
　　MessageBox(″错误: 无法修改有关注册表信息!″); 
　　return; 
　　} 
　　／／修改有关的数据 (公司名 company_Set) 
　　LPBYTE company_Set=CString_To_LPBYTE(str_company); 
　　DWORD type_2=REG_SZ; 
　　DWORD cbData_2=str_company.GetLength()＋1; 
　　long ret2=::RegSetValueEx(hKEY, ″RegisteredOrganization″, NULL, 
　　type_2, company_Set, cbData_2); 
　　if(ret2!=ERROR_SUCCESS) 
　　{ 
　　MessageBox(″错误: 无法修改有关注册表信息!″); 
　　return; 
　　 } 　　执行上面的修改注册表的操作后，可打开注册表查看具体的数值，可以看到
已经成功地修改了有关的数据了。 　　以上实例讲述了如何在VC＋＋中访问Windows98／95的系统注册表，我们可以
很方便地查询及修改注册表的任何位置的有关信息。以上的程序在Visual C＋＋ 
6.0中调试通过（Visual C＋＋ 5.0与之类似），且运行结果正确。

Answer 4

去下载一个类来用就好了
网上很多的
google一下

Answer 5

头文件：
include <winreg.h>
#include <vector>
#include <list>#define REG_RECT 0x0001
#define REG_POINT 0x0002#define MAXCHARS 4096using namespace std;typedef list<CString> STRLIST;
typedef list<CString>::iterator STRLISTITERATOR; 
typedef vector<CString> STRVECTOR;
typedef vector<CString>::iterator STRVECTORITERATOR;
typedef list<BYTE> BYTELIST;
typedef list<BYTE>::iterator BYTELISTITERATOR;
typedef list<WORD> WORDLIST;
typedef list<WORD>::iterator WORDLISTITERATOR;
typedef list<DWORD> DWORDLIST;
typedef list<DWORD>::iterator DWORDLISTITERATOR;class CRegistry
{
// Construction
public:
CRegistry(HKEY hKeyRoot = HKEY_LOCAL_MACHINE);
virtual ~CRegistry(); struct REGINFO
{
LONG lMessage;
DWORD dwType;
DWORD dwSize;
} m_Info;
// Operations
public:
BOOL VerifyKey (HKEY hKeyRoot, LPCTSTR pszPath, REGSAM samDesired = KEY_ALL_ACCESS);
BOOL VerifyKey (LPCTSTR pszPath, REGSAM samDesired = KEY_ALL_ACCESS);
BOOL VerifyValue (LPCTSTR pszValue);
BOOL CreateKey (HKEY hKeyRoot, LPCTSTR pszPath, 
DWORD dwOptions = REG_OPTION_VOLATILE, REGSAM samDesired = KEY_ALL_ACCESS);
BOOL Open (HKEY hKeyRoot, LPCTSTR pszPath, REGSAM samDesired = KEY_ALL_ACCESS);
void Close(); BOOL DeleteValue (LPCTSTR pszValue);
BOOL DeleteValueKey (HKEY hKeyRoot, LPCTSTR pszPath); BOOL Write (LPCTSTR pszKey, int iVal);
BOOL Write (LPCTSTR pszKey, DWORD dwVal);
BOOL Write (LPCTSTR pszKey, LPCTSTR pszVal);
BOOL Write (LPCTSTR pszKey, LPCRECT rcRect);
BOOL Write (LPCTSTR pszKey, LPPOINT lpPoint);

//2001-07-19 begin
/*
BOOL Write (LPCTSTR pszKey, CStringList& scStringList);
BOOL Write (LPCTSTR pszKey, CByteArray& bcArray);
BOOL Write (LPCTSTR pszKey, CStringArray& scArray);
BOOL Write (LPCTSTR pszKey, CDWordArray& dwcArray);
BOOL Write (LPCTSTR pszKey, CWordArray& wcArray);
*/

BOOL Write (LPCTSTR pszKey, STRLIST & scStringList);
BOOL Write (LPCTSTR pszKey, BYTELIST & bcArray);
BOOL Write (LPCTSTR pszKey, STRVECTOR& scArray);
BOOL Write (LPCTSTR pszKey, WORDLIST& wcArray);
BOOL Write (LPCTSTR pszKey, DWORDLIST& dwcArray);
//2001-07-19 end

BOOL Read (LPCTSTR pszKey, BYTE& iVal);
BOOL Read (LPCTSTR pszKey, int& iVal);
BOOL Read (LPCTSTR pszKey, DWORD& dwVal);
BOOL Read (LPCTSTR pszKey, CString * sVal);
BOOL Read (LPCTSTR pszKey, LPPOINT lpPoint);
BOOL Read (LPCTSTR pszKey, LPRECT rcRect); //2001-07-19 begin
/*
BOOL Read (LPCTSTR pszKey, CStringList& scStringList);
BOOL Read (LPCTSTR pszKey, CStringArray& scArray);
BOOL Read (LPCTSTR pszKey, CDWordArray& dwcArray);
BOOL Read (LPCTSTR pszKey, CWordArray& wcArray);
BOOL Read (LPCTSTR pszKey, CByteArray& bcArray);
*/
BOOL Read  (LPCTSTR pszKey, STRLIST & scStringList);
BOOL Read  (LPCTSTR pszKey, BYTELIST & bcArray);
BOOL Read (LPCTSTR pszKey, STRVECTOR& scArray);
BOOL Read (LPCTSTR pszKey, WORDLIST& wcArray);
BOOL Read (LPCTSTR pszKey, DWORDLIST& dwcArray);
//2001-07-19 end


protected:
HKEY  m_hKey;
CString m_sPath;
private:
BYTE m_byData[MAXCHARS];
};

Answer 6

原文件：1
#include "Registry.h"CRegistry::CRegistry(HKEY hKeyRoot)
{
m_hKey = hKeyRoot;
}
/////////////////////////////////////////////////////////////////////////////CRegistry::~CRegistry()
{
Close();
}
/////////////////////////////////////////////////////////////////////////////BOOL CRegistry::VerifyKey (HKEY hKeyRoot, LPCTSTR pszPath, REGSAM samDesired)
{
_ASSERT (hKeyRoot);
_ASSERT (pszPath); LONG ReturnValue = RegOpenKeyEx (hKeyRoot, pszPath, 0L,
samDesired, &m_hKey);
if(ReturnValue == ERROR_SUCCESS)
return TRUE;

m_Info.lMessage = ReturnValue;
m_Info.dwSize = 0L;
m_Info.dwType = 0L; return FALSE;
}
/////////////////////////////////////////////////////////////////////////////BOOL CRegistry::VerifyKey (LPCTSTR pszPath, REGSAM samDesired)
{
_ASSERT (m_hKey); LONG ReturnValue = RegOpenKeyEx (m_hKey, pszPath, 0L,
samDesired, &m_hKey);

m_Info.lMessage = ReturnValue;
m_Info.dwSize = 0L;
m_Info.dwType = 0L; if(ReturnValue == ERROR_SUCCESS)
return TRUE;

return FALSE;
}
/////////////////////////////////////////////////////////////////////////////BOOL CRegistry::VerifyValue (LPCTSTR pszValue)
{
_ASSERT(m_hKey);
LONG lReturn = RegQueryValueEx(m_hKey, pszValue, NULL,
NULL, NULL, NULL); m_Info.lMessage = lReturn;
m_Info.dwSize = 0L;
m_Info.dwType = 0L; if(lReturn == ERROR_SUCCESS)
return TRUE; return FALSE;
}
/////////////////////////////////////////////////////////////////////////////BOOL CRegistry::CreateKey (HKEY hKeyRoot, LPCTSTR pszPath, DWORD dwOptions, REGSAM samDesired)
{
DWORD dw; LONG ReturnValue = RegCreateKeyEx (hKeyRoot, pszPath, 0L, NULL,
dwOptions, samDesired, NULL, 
&m_hKey, &dw); m_Info.lMessage = ReturnValue;
m_Info.dwSize = 0L;
m_Info.dwType = 0L; if(ReturnValue == ERROR_SUCCESS)
return TRUE; return FALSE;
}
/////////////////////////////////////////////////////////////////////////////

Answer 7

源文件2：
BOOL CRegistry::Open (HKEY hKeyRoot, LPCTSTR pszPath, REGSAM samDesired)
{
m_sPath = pszPath; LONG ReturnValue = RegOpenKeyEx (hKeyRoot, pszPath, 0L,
samDesired, &m_hKey); m_Info.lMessage = ReturnValue;
m_Info.dwSize = 0L;
m_Info.dwType = 0L; if(ReturnValue == ERROR_SUCCESS)
return TRUE; return FALSE;
}
/////////////////////////////////////////////////////////////////////////////void CRegistry::Close()
{
if (m_hKey)
{
RegCloseKey (m_hKey);
m_hKey = NULL;
}
}
/////////////////////////////////////////////////////////////////////////////BOOL CRegistry::Write (LPCTSTR pszKey, int iVal)
{
DWORD dwValue; _ASSERT(m_hKey);
_ASSERT(pszKey);

dwValue = (DWORD)iVal;
LONG ReturnValue = RegSetValueEx (m_hKey, pszKey, 0L, REG_DWORD,
(CONST BYTE*) &dwValue, sizeof(DWORD)); m_Info.lMessage = ReturnValue;
m_Info.dwSize = sizeof(DWORD);
m_Info.dwType = REG_DWORD; if(ReturnValue == ERROR_SUCCESS)
return TRUE;

return FALSE;
}
/////////////////////////////////////////////////////////////////////////////BOOL CRegistry::Write (LPCTSTR pszKey, DWORD dwVal)
{
_ASSERT(m_hKey);
_ASSERT(pszKey);
return RegSetValueEx (m_hKey, pszKey, 0L, REG_DWORD,
(CONST BYTE*) &dwVal, sizeof(DWORD));
}
/////////////////////////////////////////////////////////////////////////////BOOL CRegistry::Write (LPCTSTR pszKey, LPCTSTR pszData)
{
_ASSERT(m_hKey);
_ASSERT(pszKey);
_ASSERT(pszData);
//_ASSERT(AfxIsValidAddress(pszData, strlen(pszData), FALSE)); LONG ReturnValue = RegSetValueEx (m_hKey, pszKey, 0L, REG_SZ,
(CONST BYTE*) pszData, strlen((LPCSTR)pszData) + 1); m_Info.lMessage = ReturnValue;
m_Info.dwSize = strlen((LPCSTR)pszData) + 1;
m_Info.dwType = REG_SZ; if(ReturnValue == ERROR_SUCCESS)
return TRUE;

return FALSE;
}
///////////////////////////////////////////////////////////////////////////////BOOL CRegistry::Write (LPCTSTR pszKey, CStringList& scStringList)
BOOL CRegistry::Write (LPCTSTR pszKey, STRLIST & scStringList)
{
_ASSERT(m_hKey);
_ASSERT(pszKey); ZeroMemory(m_byData,MAXCHARS); DWORD dwLen = 0;
int istrLen;
STRLISTITERATOR it;
for(it = scStringList.begin();it!= scStringList.end();it++)
{
istrLen = it->GetLength();
::memcpy(m_byData+dwLen,it->GetBuffer(istrLen),istrLen);
dwLen += istrLen;
m_byData[dwLen] =0;
dwLen ++;
}
_ASSERT(dwLen < MAXCHARS);
LONG lReturn = RegSetValueEx(m_hKey, pszKey, 0, REG_BINARY,
m_byData, dwLen);

m_Info.lMessage = lReturn;
m_Info.dwSize = dwLen;
m_Info.dwType = REG_BINARY; if(lReturn == ERROR_SUCCESS)
return TRUE;

return FALSE;
}
///////////////////////////////////////////////////////////////////////////////BOOL CRegistry::Write (LPCTSTR pszKey, CByteArray& bcArray)
BOOL CRegistry::Write (LPCTSTR pszKey, BYTELIST & bcArray)
{
_ASSERT(m_hKey);
_ASSERT(pszKey);

ZeroMemory(m_byData,MAXCHARS);

DWORD dwLen = 0;
BYTELISTITERATOR it;
for(it = bcArray.begin();it != bcArray.end();it++,dwLen++)
{
m_byData[dwLen]= *it;
}
_ASSERT(dwLen < MAXCHARS);
LONG lReturn = RegSetValueEx(m_hKey, pszKey, 0, REG_BINARY,
m_byData, dwLen);

m_Info.lMessage = lReturn;
m_Info.dwSize = dwLen;
m_Info.dwType = REG_BINARY; if(lReturn == ERROR_SUCCESS)
return TRUE;

return FALSE;
}
///////////////////////////////////////////////////////////////////////////////BOOL CRegistry::Write (LPCTSTR pszKey, CDWordArray& dwcArray)
BOOL CRegistry::Write (LPCTSTR pszKey, DWORDLIST& dwcArray)
{
_ASSERT(m_hKey);
_ASSERT(pszKey);

ZeroMemory(m_byData,MAXCHARS);

DWORD dwLen = 0;
DWORDLISTITERATOR it;
for(it = dwcArray.begin();it != dwcArray.end();it++)
{
memcpy(m_byData+dwLen,&(*it),sizeof(DWORD));
dwLen += sizeof(DWORD);
}
_ASSERT(dwLen < MAXCHARS);
LONG lReturn = RegSetValueEx(m_hKey, pszKey, 0, REG_BINARY,
m_byData, dwLen);

m_Info.lMessage = lReturn;
m_Info.dwSize = dwLen;
m_Info.dwType = REG_BINARY; if(lReturn == ERROR_SUCCESS)
return TRUE;

return FALSE;
}
///////////////////////////////////////////////////////////////////////////////BOOL CRegistry::Write (LPCTSTR pszKey, CWordArray& wcArray)
BOOL CRegistry::Write (LPCTSTR pszKey, WORDLIST& wcArray)
{
_ASSERT(m_hKey);
_ASSERT(pszKey);

ZeroMemory(m_byData,MAXCHARS);

DWORD dwLen = 0;
WORDLISTITERATOR it;
for(it = wcArray.begin();it != wcArray.end();it++)
{
memcpy(m_byData+dwLen,&(*it),sizeof(WORD));
dwLen += sizeof(WORD);
}
_ASSERT(dwLen < MAXCHARS);
LONG lReturn = RegSetValueEx(m_hKey, pszKey, 0, REG_BINARY,
m_byData, dwLen);

m_Info.lMessage = lReturn;
m_Info.dwSize = dwLen;
m_Info.dwType = REG_BINARY; if(lReturn == ERROR_SUCCESS)
return TRUE;

return FALSE;
}
///////////////////////////////////////////////////////////////////////////////BOOL CRegistry::Write (LPCTSTR pszKey, CStringArray& scArray)
BOOL CRegistry::Write (LPCTSTR pszKey, STRVECTOR& scArray)
{
_ASSERT(m_hKey);
_ASSERT(pszKey);

ZeroMemory(m_byData,MAXCHARS);

DWORD dwLen = 0;
int iStrLen;
for(STRVECTORITERATOR it = scArray.begin();it != scArray.end();it++)
{
iStrLen = it->GetLength();
memcpy(m_byData+dwLen,it->GetBuffer(iStrLen),iStrLen);
dwLen += iStrLen ; 
m_byData[dwLen] =0;
dwLen ++;
}
_ASSERT(dwLen < MAXCHARS);
LONG lReturn = RegSetValueEx(m_hKey, pszKey, 0, REG_BINARY,
m_byData, dwLen);

m_Info.lMessage = lReturn;
m_Info.dwSize = dwLen;
m_Info.dwType = REG_BINARY; if(lReturn == ERROR_SUCCESS)
return TRUE;

return FALSE;
}
/////////////////////////////////////////////////////////////////////////////BOOL CRegistry::Write(LPCTSTR pszKey, LPCRECT rcRect)
{
_ASSERT(m_hKey);
_ASSERT(pszKey); DWORDLIST dwcList;

dwcList.insert(dwcList.end(),rcRect->top);
dwcList.insert(dwcList.end(),rcRect->bottom);
dwcList.insert(dwcList.end(),rcRect->left);
dwcList.insert(dwcList.end(),rcRect->right);

return Write(pszKey,dwcList);
}
/////////////////////////////////////////////////////////////////////////////BOOL CRegistry::Write(LPCTSTR pszKey, LPPOINT lpPoint)
{
_ASSERT(m_hKey);
_ASSERT(pszKey); DWORDLIST dwcList;
dwcList.insert(dwcList.end(),lpPoint->x);
dwcList.insert(dwcList.end(),lpPoint->y);

return Write(pszKey,dwcList);
}

Answer 8

源码3：
BOOL CRegistry::Read(LPCTSTR pszKey, BYTE& iVal)
{
_ASSERT(m_hKey);
_ASSERT(pszKey); DWORD dwType;
DWORD dwSize = sizeof (DWORD);
DWORD dwDest; LONG lReturn = RegQueryValueEx (m_hKey, (LPSTR) pszKey, NULL,
&dwType, (BYTE *) &dwDest, &dwSize); m_Info.lMessage = lReturn;
m_Info.dwType = dwType;
m_Info.dwSize = dwSize; if(lReturn == ERROR_SUCCESS)
{
iVal = (BYTE)dwDest;
return TRUE;
} return FALSE;
}
/////////////////////////////////////////////////////////////////////////////BOOL CRegistry::Read(LPCTSTR pszKey, int& iVal)
{
_ASSERT(m_hKey);
_ASSERT(pszKey); DWORD dwType;
DWORD dwSize = sizeof (DWORD);
DWORD dwDest; LONG lReturn = RegQueryValueEx (m_hKey, (LPSTR) pszKey, NULL,
&dwType, (BYTE *) &dwDest, &dwSize); m_Info.lMessage = lReturn;
m_Info.dwType = dwType;
m_Info.dwSize = dwSize; if(lReturn == ERROR_SUCCESS)
{
iVal = (int)dwDest;
return TRUE;
} return FALSE;
}
/////////////////////////////////////////////////////////////////////////////BOOL CRegistry::Read (LPCTSTR pszKey, DWORD& dwVal)
{
_ASSERT(m_hKey);
_ASSERT(pszKey); DWORD dwType;
DWORD dwSize = sizeof (DWORD);
DWORD dwDest; LONG lReturn = RegQueryValueEx (m_hKey, (LPSTR) pszKey, NULL, 
&dwType, (BYTE *) &dwDest, &dwSize); m_Info.lMessage = lReturn;
m_Info.dwType = dwType;
m_Info.dwSize = dwSize; if(lReturn == ERROR_SUCCESS)
{
dwVal = dwDest;
return TRUE;
} return FALSE;
}
/////////////////////////////////////////////////////////////////////////////BOOL CRegistry::Read (LPCTSTR pszKey, CString * sVal)
{
_ASSERT(m_hKey);
_ASSERT(pszKey); DWORD dwType;
DWORD dwSize = 200;
char  szString[255]; LONG lReturn = RegQueryValueEx (m_hKey, (LPSTR) pszKey, NULL,
&dwType, (BYTE *) szString, &dwSize); m_Info.lMessage = lReturn;
m_Info.dwType = dwType;
m_Info.dwSize = dwSize; if(lReturn == ERROR_SUCCESS)
{
*sVal = szString;
return TRUE;
} return FALSE;
}
///////////////////////////////////////////////////////////////////////////////BOOL CRegistry::Read (LPCTSTR pszKey, CStringList& scStringList)
BOOL CRegistry::Read (LPCTSTR pszKey, STRLIST & scStringList)
{
_ASSERT(m_hKey);
_ASSERT(pszKey); ZeroMemory(m_byData,MAXCHARS);

DWORD dwType;
DWORD dwData = MAXCHARS;

LONG lReturn = RegQueryValueEx(m_hKey, pszKey, NULL, &dwType,
m_byData, &dwData); m_Info.lMessage = lReturn;
m_Info.dwType = dwType;
m_Info.dwSize = dwData; if(lReturn == ERROR_SUCCESS && dwType == REG_BINARY)
{
_ASSERT(dwData < MAXCHARS);

CString str;
for(DWORD i =0;i< dwData;i += (str.GetLength()+1))
{
str.Empty();
str=(LPCTSTR)m_byData+i;
scStringList.insert(scStringList.end(),str);  
}
} if(lReturn == ERROR_SUCCESS)
return TRUE; return FALSE;
}
///////////////////////////////////////////////////////////////////////////////BOOL CRegistry::Read (LPCTSTR pszKey, CByteArray& bcArray)
BOOL CRegistry::Read (LPCTSTR pszKey, BYTELIST & bcArray)
{
_ASSERT(m_hKey);
_ASSERT(pszKey); ZeroMemory(m_byData,MAXCHARS);

DWORD dwType;
DWORD dwData = MAXCHARS;

LONG lReturn = RegQueryValueEx(m_hKey, pszKey, NULL, &dwType,
m_byData, &dwData); m_Info.lMessage = lReturn;
m_Info.dwType = dwType;
m_Info.dwSize = dwData; if(lReturn == ERROR_SUCCESS && dwType == REG_BINARY)
{
_ASSERT(dwData < MAXCHARS);
for (DWORD i = 0 ;i< dwData;i++)
bcArray.insert(bcArray.end(),m_byData[i]);
} if(lReturn == ERROR_SUCCESS)
return TRUE; return FALSE;
}
///////////////////////////////////////////////////////////////////////////////BOOL CRegistry::Read (LPCTSTR pszKey, CDWordArray& dwcArray)
BOOL CRegistry::Read (LPCTSTR pszKey, DWORDLIST& dwcArray)
{
_ASSERT(m_hKey);
_ASSERT(pszKey); ZeroMemory(m_byData,MAXCHARS);

DWORD dwType;
DWORD dwData = MAXCHARS;

LONG lReturn = RegQueryValueEx(m_hKey, pszKey, NULL, &dwType,
m_byData, &dwData); m_Info.lMessage = lReturn;
m_Info.dwType = dwType;
m_Info.dwSize = dwData; if(lReturn == ERROR_SUCCESS && dwType == REG_BINARY)
{
_ASSERT(dwData < MAXCHARS);
DWORD * pdwData;
for(DWORD  i=0 ; i< dwData ; i+= sizeof(DWORD))
{
pdwData = (DWORD *)(m_byData+i);
dwcArray.insert(dwcArray.end(),*pdwData);
}
} if(lReturn == ERROR_SUCCESS)
return TRUE; return FALSE;
}
///////////////////////////////////////////////////////////////////////////////BOOL CRegistry::Read (LPCTSTR pszKey, CWordArray& wcArray)
BOOL CRegistry::Read (LPCTSTR pszKey, WORDLIST& wcArray)
{
_ASSERT(m_hKey);
_ASSERT(pszKey); ZeroMemory(m_byData,MAXCHARS); DWORD dwType;
DWORD dwData = MAXCHARS;

LONG lReturn = RegQueryValueEx(m_hKey, pszKey, NULL, &dwType,
m_byData, &dwData); m_Info.lMessage = lReturn;
m_Info.dwType = dwType;
m_Info.dwSize = dwData; if(lReturn == ERROR_SUCCESS && dwType == REG_BINARY)
{
_ASSERT(dwData < MAXCHARS);
WORD * pwData;
for(DWORD i =0 ; i< dwData;i+= sizeof(WORD))
{
pwData = (WORD *)(m_byData+i);
wcArray.insert(wcArray.end(),*pwData);
}
} if(lReturn == ERROR_SUCCESS)
return TRUE; return FALSE;
}
///////////////////////////////////////////////////////////////////////////////BOOL CRegistry::Read (LPCTSTR pszKey, CStringArray& scArray)
BOOL CRegistry::Read (LPCTSTR pszKey, STRVECTOR& scArray)
{
_ASSERT(m_hKey);
_ASSERT(pszKey);

ZeroMemory(m_byData,MAXCHARS); DWORD dwType;
DWORD dwData = MAXCHARS;

LONG lReturn = RegQueryValueEx(m_hKey, pszKey, NULL, &dwType,
m_byData, &dwData); m_Info.lMessage = lReturn;
m_Info.dwType = dwType;
m_Info.dwSize = dwData; if(lReturn == ERROR_SUCCESS && dwType == REG_BINARY)
{
_ASSERT(dwData < MAXCHARS);
CString str;
for(DWORD i =0;i<dwData;i += (str.GetLength()+1))
{
str.Empty();
str=(LPCTSTR)m_byData+i;
scArray.insert(scArray.end(),str);  
}
} if(lReturn == ERROR_SUCCESS)
return TRUE; return FALSE;
}
/////////////////////////////////////////////////////////////////////////////BOOL CRegistry::Read(LPCTSTR pszKey, LPRECT rcRect)
{
_ASSERT(m_hKey);
_ASSERT(pszKey); DWORDLIST dwcList;
DWORDLISTITERATOR it;

if(Read(pszKey,dwcList))
{
it = dwcList.begin(); 
rcRect->top = *it;
it++;
rcRect->bottom = *it;
it++;
rcRect->left = *it;
it++;
rcRect->right = *it;
m_Info.dwType = REG_RECT;
m_Info.dwSize = sizeof(RECT); return TRUE;
}
else
{
return FALSE;
}
}
/////////////////////////////////////////////////////////////////////////////BOOL CRegistry::Read(LPCTSTR pszKey, LPPOINT lpPoint)
{
_ASSERT(m_hKey);
_ASSERT(pszKey); DWORDLIST dwcList;
DWORDLISTITERATOR it;

if(Read(pszKey,dwcList))
{
it = dwcList.begin();
lpPoint->x = *it;
it++;
lpPoint->y = *it;
m_Info.dwType = REG_POINT;
m_Info.dwSize = sizeof(POINT);
return TRUE;
}
else
{
return FALSE;
}
}
/////////////////////////////////////////////////////////////////////////////BOOL CRegistry::DeleteValue (LPCTSTR pszValue)
{
_ASSERT(m_hKey);
LONG lReturn = RegDeleteValue(m_hKey, pszValue);
m_Info.lMessage = lReturn;
m_Info.dwType = 0L;
m_Info.dwSize = 0L; if(lReturn == ERROR_SUCCESS)
return TRUE; return FALSE;
}
/////////////////////////////////////////////////////////////////////////////BOOL CRegistry::DeleteValueKey (HKEY hKeyRoot, LPCTSTR pszPath)
{
_ASSERT(pszPath);
_ASSERT(hKeyRoot); LONG lReturn = RegDeleteKey(hKeyRoot, pszPath); m_Info.lMessage = lReturn;
m_Info.dwType = 0L;
m_Info.dwSize = 0L; if(lReturn == ERROR_SUCCESS)
return TRUE; return FALSE;
}
/////////////////////////////////////////////////////////////////////////////

Answer 9

有这个必要吗？不用写这么多吧。。
简单的读写注册表：首先在程序的  initinstance（） 里写一个
SetRegistryKey（“键名”）；然后在程序中你可以任意处写 WriteProfileString("","",..);
GetProfileString("","",..);因我原来只用GetProFileInt的，所以你自己查一下msdn就可以了这种情况写在了HEKY_CURRENT_USER  的 softWare下面，很简单的
如果想写在machine或什么下面就要参看SetRegistryKey了，也不困难