The function of setregistrykey

Time:2021-2-8

come from: http://blog.sina.com.cn/s/blog_ 65cab32d01012a0l.html

 

When using the MFC framework, there is always a setregistrykey (“string XXX”) in the initinstance() function of the app application class during initialization. I don’t know what it is used for. I checked it carefully this day and found that if you use the registry, it provides you with a very convenient method. Of course, if you don’t use the system registry, this sentence can be commented out.

Here are some information I found on the Internet:

SetRegistryKey Causes application settings to be stored in the registry instead of .INI files.

The function of setregistrykey is to set the registry access key of MFC program, and map the member function of reading and writing INI file to the reading and writing registry. As long as you call setregistrykey and specify the registry key value, the following six member functions will be mapped to the registry for reading~

WriteProfileBinary Writes binary data to an entry in the application’s .INI file.
WriteProfileInt Writes an integer to an entry in the application’s .INI file.
WriteProfileString Writes a string to an entry in the application’s .INI file.

 

GetProfileBinary Retrieves binary data from an entry in the application’s .INI file.
GetProfileInt Retrieves an integer from an entry in the application’s .INI file.
GetProfileString Retrieves a string from an entry in the application’s .INI file.


MSDN writes the above six functions to INI file. So I ignored its function of accessing the registry. Inadvertently read its MFC implementation to understand.

Examples are as follows:
        SetRegistryKey(_ T (“Boli’s app”); / / here is to prepare HKEY in the registry_ CURRENT_ Generate a Boli’s app branch under user \ \ software ~ why is it preparation? Because if you don’t call related functions, such as the six functions mentioned above, it won’t really read and write the registry. Specific MFC implementation excerpt at the bottom of this article.
        CString strUserName,strPassword;
Writeprofilestring (“LogInfo”, “user name”, struser name); / / register HKEY_ CURRENT_ User \ \ software \ \ Boli’s app \ \ LogInfo \ \ write the serial key value of the user name character under the branch~
Writeprofilestring (“LogInfo”, “password”, strpassword); / / same as above~

Struser name = getprofilestring (“LogInfo”, “user name”); / / here is to read HKEY_ CURRENT_ User \ \ software \ \ Boli’s app \ \ LogInfo \ \ the string key value of the user name under the branch to struser name~
        strPassword = GetProfileString(“LogInfo”,”Password”);

If you do not read or write the registry in the class derived from cwinapp, you can directly use the
        strUserName = theApp.GetProfileString(“LogInfo”,”UserName”);
        strPassword = theApp.GetProfileString(“LogInfo”,”Password”);
Or
        strUserName = AfxGetApp()->GetProfileString(“LogInfo”,”UserName”);
All roads lead to Rome.

       

The following is the MFC implementation code:

////////////////////////////////////////////////////////////////////////////
// CWinApp Settings Helpers
#ifdef AFX_INIT_SEG
#pragma code_seg(AFX_INIT_SEG)
#endif
void CWinApp::SetRegistryKey(LPCTSTR lpszRegistryKey)
{
ASSERT(m_pszRegistryKey == NULL);
ASSERT(lpszRegistryKey != NULL);
ASSERT(m_pszAppName != NULL);
BOOL bEnable = AfxEnableMemoryTracking(FALSE);
free((void*)m_pszRegistryKey);
m_pszRegistryKey = _tcsdup(lpszRegistryKey);
free((void*)m_pszProfileName);
m_pszProfileName = _tcsdup(m_pszAppName);
AfxEnableMemoryTracking(bEnable);
}
void CWinApp::SetRegistryKey(UINT nIDRegistryKey)
{
ASSERT(m_pszRegistryKey == NULL);
TCHAR szRegistryKey[256];
VERIFY(AfxLoadString(nIDRegistryKey, szRegistryKey));
SetRegistryKey(szRegistryKey);
}
// returns key for HKEY_CURRENT_USER”Software”\RegistryKey\ProfileName
// creating it if it doesn’t exist
// responsibility of the caller to call RegCloseKey() on the returned HKEY
HKEY CWinApp::GetAppRegistryKey()
{
ASSERT(m_pszRegistryKey != NULL);
ASSERT(m_pszProfileName != NULL);
HKEY hAppKey = NULL;
HKEY hSoftKey = NULL;
HKEY hCompanyKey = NULL;
if (RegOpenKeyEx(HKEY_CURRENT_USER, _T(“software”), 0, KEY_WRITE | KEY_READ,
&hSoftKey) == ERROR_SUCCESS)
{
DWORD dw;
if (RegCreateKeyEx(hSoftKey, m_pszRegistryKey, 0, REG_NONE,
REG_OPTION_NON_VOLATILE, KEY_WRITE | KEY_READ, NULL,
&hCompanyKey, &dw) == ERROR_SUCCESS)
{
RegCreateKeyEx(hCompanyKey, m_pszProfileName, 0, REG_NONE,
REG_OPTION_NON_VOLATILE, KEY_WRITE | KEY_READ, NULL,
&hAppKey, &dw);
}
}
if (hSoftKey != NULL)
RegCloseKey(hSoftKey);
if (hCompanyKey != NULL)
RegCloseKey(hCompanyKey);
return hAppKey;
}
// returns key for:
// HKEY_CURRENT_USER”Software”\RegistryKey\AppName\lpszSection
// creating it if it doesn’t exist.
// responsibility of the caller to call RegCloseKey() on the returned HKEY
HKEY CWinApp::GetSectionKey(LPCTSTR lpszSection)
{
ASSERT(lpszSection != NULL);
HKEY hSectionKey = NULL;
HKEY hAppKey = GetAppRegistryKey();
if (hAppKey == NULL)
return NULL;
DWORD dw;
RegCreateKeyEx(hAppKey, lpszSection, 0, REG_NONE,
REG_OPTION_NON_VOLATILE, KEY_WRITE | KEY_READ, NULL,
&hSectionKey, &dw);
RegCloseKey(hAppKey);
return hSectionKey;
}
UINT CWinApp::GetProfileInt(LPCTSTR lpszSection, LPCTSTR lpszEntry,
int nDefault)
{
ASSERT(lpszSection != NULL);
ASSERT(lpszEntry != NULL);
if (m_pszRegistryKey != NULL) // use registry
{
HKEY hSecKey = GetSectionKey(lpszSection);
if (hSecKey == NULL)
return nDefault;
DWORD dwValue;
DWORD dwType;
DWORD dwCount = sizeof(DWORD);
LONG lResult = RegQueryValueEx(hSecKey, (LPTSTR)lpszEntry, NULL, &dwType,
(LPBYTE)&dwValue, &dwCount);
RegCloseKey(hSecKey);
if (lResult == ERROR_SUCCESS)
{
ASSERT(dwType == REG_DWORD);
ASSERT(dwCount == sizeof(dwValue));
return (UINT)dwValue;
}
return nDefault;
}
else
{
ASSERT(m_pszProfileName != NULL);
return ::GetPrivateProfileInt(lpszSection, lpszEntry, nDefault,
m_pszProfileName);
}
}
CString CWinApp::GetProfileString(LPCTSTR lpszSection, LPCTSTR lpszEntry,
LPCTSTR lpszDefault)
{
ASSERT(lpszSection != NULL);
ASSERT(lpszEntry != NULL);
if (m_pszRegistryKey != NULL)
{
HKEY hSecKey = GetSectionKey(lpszSection);
if (hSecKey == NULL)
return lpszDefault;
CString strValue;
DWORD dwType, dwCount;
LONG lResult = RegQueryValueEx(hSecKey, (LPTSTR)lpszEntry, NULL, &dwType,
NULL, &dwCount);
if (lResult == ERROR_SUCCESS)
{
ASSERT(dwType == REG_SZ);
lResult = RegQueryValueEx(hSecKey, (LPTSTR)lpszEntry, NULL, &dwType,
(LPBYTE)strValue.GetBuffer(dwCount / sizeof(TCHAR)), &dwCount);
strValue.ReleaseBuffer();
}
RegCloseKey(hSecKey);
if (lResult == ERROR_SUCCESS)
{
ASSERT(dwType == REG_SZ);
return strValue;
}
return lpszDefault;
}
else
{
ASSERT(m_pszProfileName != NULL);
if (lpszDefault == NULL)
lpszDefault = _T(“”); // don’t pass in NULL
TCHAR szT[4096];
DWORD dw = ::GetPrivateProfileString(lpszSection, lpszEntry,
lpszDefault, szT, _countof(szT), m_pszProfileName);
ASSERT(dw < 4095);
return szT;
}
}
BOOL CWinApp::GetProfileBinary(LPCTSTR lpszSection, LPCTSTR lpszEntry,
BYTE** ppData, UINT* pBytes)
{
ASSERT(lpszSection != NULL);
ASSERT(lpszEntry != NULL);
ASSERT(ppData != NULL);
ASSERT(pBytes != NULL);
*ppData = NULL;
*pBytes = 0;
if (m_pszRegistryKey != NULL)
{
HKEY hSecKey = GetSectionKey(lpszSection);
if (hSecKey == NULL)
return FALSE;
DWORD dwType, dwCount;
LONG lResult = RegQueryValueEx(hSecKey, (LPTSTR)lpszEntry, NULL, &dwType,
NULL, &dwCount);
*pBytes = dwCount;
if (lResult == ERROR_SUCCESS)
{
ASSERT(dwType == REG_BINARY);
*ppData = new BYTE[*pBytes];
lResult = RegQueryValueEx(hSecKey, (LPTSTR)lpszEntry, NULL, &dwType,
*ppData, &dwCount);
}
RegCloseKey(hSecKey);
if (lResult == ERROR_SUCCESS)
{
ASSERT(dwType == REG_BINARY);
return TRUE;
}
else
{
delete[] * ppData;
*ppData = NULL;
}
return FALSE;
}
else
{
ASSERT(m_pszProfileName != NULL);
CString str = GetProfileString(lpszSection, lpszEntry, NULL);
if (str.IsEmpty())
return FALSE;
ASSERT(str.GetLength() % 2 == 0);
INT_PTR nLen = str.GetLength();
*pBytes = UINT(nLen) / 2;
*ppData = new BYTE[*pBytes];
for (int i = 0; i < nLen; i += 2)
{
(*ppData)[i / 2] = (BYTE)
(((str[i + 1] – ‘A’) << 4) + (str[i] – ‘A’));
}
return TRUE;
}
}
#ifdef AFX_CORE3_SEG
#pragma code_seg(AFX_CORE3_SEG)
#endif
BOOL CWinApp::WriteProfileInt(LPCTSTR lpszSection, LPCTSTR lpszEntry,
int nValue)
{
ASSERT(lpszSection != NULL);
ASSERT(lpszEntry != NULL);
if (m_pszRegistryKey != NULL)
{
HKEY hSecKey = GetSectionKey(lpszSection);
if (hSecKey == NULL)
return FALSE;
LONG lResult = RegSetValueEx(hSecKey, lpszEntry, NULL, REG_DWORD,
(LPBYTE)&nValue, sizeof(nValue));
RegCloseKey(hSecKey);
return lResult == ERROR_SUCCESS;
}
else
{
ASSERT(m_pszProfileName != NULL);
TCHAR szT[16];
wsprintf(szT, _T(“%d”), nValue);
return ::WritePrivateProfileString(lpszSection, lpszEntry, szT,
m_pszProfileName);
}
}
BOOL CWinApp::WriteProfileString(LPCTSTR lpszSection, LPCTSTR lpszEntry,
LPCTSTR lpszValue)
{
ASSERT(lpszSection != NULL);
if (m_pszRegistryKey != NULL)
{
LONG lResult;
if (lpszEntry == NULL) //delete whole section
{
HKEY hAppKey = GetAppRegistryKey();
if (hAppKey == NULL)
return FALSE;
lResult = ::RegDeleteKey(hAppKey, lpszSection);
RegCloseKey(hAppKey);
}
else if (lpszValue == NULL)
{
HKEY hSecKey = GetSectionKey(lpszSection);
if (hSecKey == NULL)
return FALSE;
// necessary to cast away const below
lResult = ::RegDeleteValue(hSecKey, (LPTSTR)lpszEntry);
RegCloseKey(hSecKey);
}
else
{
HKEY hSecKey = GetSectionKey(lpszSection);
if (hSecKey == NULL)
return FALSE;
lResult = RegSetValueEx(hSecKey, lpszEntry, NULL, REG_SZ,
(LPBYTE)lpszValue, (lstrlen(lpszValue) + 1) * sizeof(TCHAR));
RegCloseKey(hSecKey);
}
return lResult == ERROR_SUCCESS;
}
else
{
ASSERT(m_pszProfileName != NULL);
ASSERT(lstrlen(m_pszProfileName) < 4095); // can’t read in bigger
return ::WritePrivateProfileString(lpszSection, lpszEntry, lpszValue,
m_pszProfileName);
}
}
BOOL CWinApp::WriteProfileBinary(LPCTSTR lpszSection, LPCTSTR lpszEntry,
LPBYTE pData, UINT nBytes)
{
ASSERT(lpszSection != NULL);
if (m_pszRegistryKey != NULL)
{
LONG lResult;
HKEY hSecKey = GetSectionKey(lpszSection);
if (hSecKey == NULL)
return FALSE;
lResult = RegSetValueEx(hSecKey, lpszEntry, NULL, REG_BINARY,
pData, nBytes);
RegCloseKey(hSecKey);
return lResult == ERROR_SUCCESS;
}
// convert to string and write out
LPTSTR lpsz = new TCHAR[nBytes * 2 + 1];
UINT i;
for (i = 0; i < nBytes; i++)
{
lpsz[i * 2] = (TCHAR)((pData[i] & 0x0F) + ‘A’); //low nibble
lpsz[i * 2 + 1] = (TCHAR)(((pData[i] >> 4) & 0x0F) + ‘A’); //high nibble
}
lpsz[i * 2] = 0;
ASSERT(m_pszProfileName != NULL);
BOOL bResult = WriteProfileString(lpszSection, lpszEntry, lpsz);
delete[] lpsz;
return bResult;
}

Recommended Today

Rust and python: why rust can replace Python

In this guide, we compare the rust and python programming languages. We will discuss the applicable use cases in each case, review the advantages and disadvantages of using rust and python, and explain why rust might replace python. I will introduce the following: What is rust? What is Python? When to use rust When to […]