读写windows注册表

　　最近有在做一写读写配置文件的项目内容，了解到注册表也可以写配置，于是顺便连接一下读写注册表的内容。

MFC上读写注册表

MFC的
CWinApp 类提供了很容易的注册表访问函数~~以前从来没注意过~~还到处找读写注册表的办法~~ -_-! 看下面几个成员函数~

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

SetRegistryKey 这个函数功能是设置MFC程序的注册表访问键，并把读写 ini 文件的成员函数映射到读写注册表。只要调用一下 SetRegistryKey 并指定注册表键值，那么下面6个成员函数，就被映射到进行注册表读取了~

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上面写上面6个函数是写到INI文件的。所以俺就忽略了其访问注册表的功能。无意中看了其MFC实现才有所了解。

例子如下：
SetRegistryKey(_T("boli‘s app")); //这里是准备在注册表HKEY_CURRENT_USER\\software 下面生成一个boli‘s app 分支~为什么说是准备呢？因为如果不调用相关函数，如上面提到的6个函数，它是不会真正读写注册表的。具体本文最最下面的MFC实现摘录。
CString strUserName,strPassword;
WriteProfileString("LogInfo","UserName",strUserName); //向注册表HKEY_CURRENT_USER\\software\\boli‘s app\\LogInfo\\分支下写入 UserName 字符串行键值~
WriteProfileString("LogInfo","Password",strPassword);//同上~

strUserName = GetProfileString("LogInfo","UserName");// 这里是读取HKEY_CURRENT_USER\\software\\boli‘s app\\LogInfo\\分支下的 UserName 字符串键值到 strUserName~
 strPassword =  GetProfileString("LogInfo","Password");

如果不是在CWinApp 派生的类中读写注册表，可以直接用：
 strUserName = theApp.GetProfileString("LogInfo","UserName");
 strPassword = theApp.GetProfileString("LogInfo","Password");
或 
 strUserName = AfxGetApp()->GetProfileString("LogInfo","UserName");
条条大路通罗马。

看看MFC的代码吧~~SDK高手们不屑MFC，但有时候看看MFC的代码会到学习SDK，windows api有很大的帮助~ ：P
////////////////////////////////////////////////////////////////////////////
// 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;
}

  1. #include <iostream>
  2. #include <algorithm>
  3. #include <cmath>
  4. #include <vector>
  5. #include <string>
  6. #include <cstring>
  7. #include <atlbase.h>
  8. #include <Windows.h>
  9. #pragma warning(disable:4996)
  10. using namespace std;
  11. void read_dword()//读取操作表,其类型为DWORD
  12. {
  13. HKEY hKEY;//定义有关的键，在查询结束时关闭
  14. //打开与路径data_Set相关的hKEY
  15. LPCTSTR data_set = _T("Software\\Chicony\\Lenovo1");
  16. //访问注册表，hKEY则保存此函数所打开的键的句柄
  17. if (ERROR_SUCCESS == ::RegOpenKeyEx(HKEY_CURRENT_USER, data_set, 0, KEY_READ, &hKEY))
  18. {
  19. DWORD dwValue;//长整型数据，如果是字符串数据用char数组
  20. DWORD dwSize = sizeof(DWORD);
  21. DWORD dwType = REG_DWORD;
  22. if (::RegQueryValueEx(hKEY, _T("123"), 0, &dwType, (LPBYTE)&dwValue, &dwSize) != ERROR_SUCCESS)
  23. {
  24. cout << "错误：无法查询有关的注册表信息" << endl;
  25. }
  26. cout << dwValue << endl;
  27. }
  28. ::RegCloseKey(hKEY);
  29. }
  30. void read_reg_sz()//读取操作表,其类型为REG_SZ
  31. {
  32. HKEY hkey;
  33. LPCTSTR data_set = _T("Software\\Chicony\\Lenovo1");
  34. if (ERROR_SUCCESS == ::RegOpenKeyEx(HKEY_CURRENT_USER, data_set, 0, KEY_READ, &hkey))
  35. {
  36. char dwValue[256];
  37. DWORD dwSzType = REG_SZ;
  38. DWORD dwSize = sizeof(dwValue);
  39. if (::RegQueryValueEx(hkey, _T("wangchong"), 0, &dwSzType, (LPBYTE)&dwValue, &dwSize) != ERROR_SUCCESS)
  40. {
  41. cout << "无法查询有关的注册表信息" << endl;
  42. }
  43. cout << dwValue<< endl;
  44. }
  45. ::RegCloseKey(hkey);
  46. }
  47. void write_dword()//在\Software\\Chicony\\Lenovo1文件夹下写入一个test111的子键，设置其名称为Name，其值为6
  48. {
  49. HKEY hkey;//定义有关的hkey，在查询结束时要关闭
  50. HKEY hTempKey;
  51. DWORD dwValue = 6;
  52. DWORD dwSize = sizeof(DWORD);
  53. DWORD dwType = REG_DWORD;
  54. LPCTSTR data_set= _T("Software\\Chicony\\Lenovo1");
  55. if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_CURRENT_USER, data_set, 0, KEY_SET_VALUE, &hkey))
  56. {
  57. if (ERROR_SUCCESS == ::RegCreateKey(hkey, _T("test111"), &hTempKey))
  58. {
  59. if (ERROR_SUCCESS != ::RegSetValueEx(hTempKey, _T("Name"), 0, REG_DWORD, (CONST BYTE*)&dwValue, sizeof(DWORD)))
  60. {
  61. cout <<"写入注册表失败"<< endl;
  62. }
  63. }
  64. }
  65. ::RegCloseKey(hkey);
  66. }
  67. void write_reg_sz()
  68. {
  69. HKEY hkey;
  70. HKEY hTempKey;
  71. char m_name_set[256]="China";
  72. DWORD len = strlen(m_name_set) + 1;
  73. LPCTSTR data_set = _T("Software\\Chicony\\Lenovo1");
  74. if (ERROR_SUCCESS == ::RegOpenKeyEx(HKEY_CURRENT_USER, data_set, 0, KEY_SET_VALUE, &hkey))
  75. {
  76. if (ERROR_SUCCESS == ::RegCreateKey(hkey,_T("test1112"),&hTempKey))
  77. {
  78. if (ERROR_SUCCESS!=::RegSetValueEx(hTempKey,_T("Name"),0,REG_SZ,(const BYTE*)m_name_set,len))
  79. {
  80. cout << "写入错误" << endl;
  81. }
  82. }
  83. }
  84. ::RegCloseKey(hkey);
  85. }
  86. void write_binary()
  87. {
  88. HKEY hkey;
  89. HKEY hTempKey;
  90. BYTE m_name[10];
  91. memset(m_name, 0, sizeof(m_name));
  92. m_name[0] = 0xff;
  93. m_name[1] = 0xac;
  94. m_name[2] = 0x05;
  95. m_name[3] = 0x4e;
  96. LPCTSTR data_set= _T("Software\\Chicony\\Lenovo1");
  97. if (ERROR_SUCCESS == ::RegOpenKeyEx(HKEY_CURRENT_USER, data_set, 0, KEY_SET_VALUE, &hkey))
  98. {
  99. if (ERROR_SUCCESS==::RegCreateKey(hkey,_T("test111"),&hTempKey))
  100. {
  101. if (ERROR_SUCCESS != ::RegSetValueEx(hTempKey, _T("Name"), 0, REG_BINARY, (unsigned char *)m_name, 5))
  102. {
  103. cout << "写入错误" << endl;
  104. }
  105. }
  106. }
  107. ::RegCloseKey(hkey);
  108. }
  109. void delete_value()
  110. {
  111. HKEY hkey;
  112. LPCTSTR data_set = _T("Software\\Chicony\\Lenovo1\\test1112");
  113. if (ERROR_SUCCESS == ::RegOpenKeyEx(HKEY_CURRENT_USER, data_set, 0, KEY_SET_VALUE, &hkey))
  114. {
  115. if (ERROR_SUCCESS != ::RegDeleteValue(hkey, _T("Name")))
  116. {
  117. cout << "删除错误" << endl;
  118. }
  119. }
  120. ::RegCloseKey(hkey);
  121. }
  122. void delete_key()
  123. {
  124. HKEY hkey;
  125. LPCTSTR data_set = _T("Software\\Chicony\\Lenovo1");
  126. if (ERROR_SUCCESS == ::RegOpenKeyEx(HKEY_CURRENT_USER, data_set, 0, KEY_SET_VALUE, &hkey))
  127. {
  128. if (ERROR_SUCCESS != ::RegDeleteKey(hkey,"test1112"))
  129. {
  130. cout << "删除错误" << endl;
  131. }
  132. }
  133. ::RegCloseKey(hkey);
  134. }
  135. int main()
  136. {
  137. read_dword();
  138. read_reg_sz();
  139. write_reg_sz();
  140. write_binary();
  141. delete_value();
  142. delete_key();
  143. system("pause");
  144. return 0;
  145. }

时间： 2024-09-30 04:47:52

读写windows注册表的相关文章

python3读写windows注册表实例

网上的很多代码真的只能参考,有很多停留在python2的编码风格或者没更新新模块的语法沿用语法编写!(当然这是个人观点,如果是系统工程的编码优点还望指正) winreg是内置模块,不用安装,直接上码 import winreg dict1 = {} #新建字典 reg_name = [] #新建数组,存放注册表名 reg_value = [] #新建数组,存放注册表值 key = winreg.CreateKey(winreg.HKEY_CURRENT_USER, r"Software\Micr

QSettings配置读写-win注册表操作-ini文件读写

版权声明:若无来源注明,Techie亮博客文章均为原创. 转载请以链接形式标明本文标题和地址: 本文标题:QSettings配置读写-win注册表操作-ini文件读写     本文地址:http://techieliang.com/2017/12/674/ 文章目录 1. 介绍 2. 创建配置文件  2.1. 配置格式  2.2. 作用域  2.3. 关于组织.程序名 3. 配置文件读写 4. 范例  4.1. win下SystemScope.IniFormat  4.2. win下UserSc

32位程序访问64位系统上的Windows注册表

今天在工作的过程中遇到个奇怪的为问题,就是通过c#获取注册表键值的问题,一般都比较简单: string SQLPath = string.Empty; RegistryKey hkml = Registry.LocalMachine; RegistryKey MSSQLServerKey = hkml.OpenSubKey(@"SOFTWARE\MICROSOFT\MSSQLServer"); if (MSSQLServerKey != null) { string[] keys =

Windows 注册表

<1>64位操作系统上的注册表 <2>文件系统重定向 <3>UAC <4>注册表重定向 <5>SysWoW64 <6>注册表存放位置 <7>注册表跟环境变量 <1>64位操作系统 在64位的操作系统中有64位版本的注册表编辑器以及32版本的注册表编辑器,64版本的注册表在C:\Windows\regedit.exe,32位版本的在C:\Windows\SysWow64\regedit.exe. 注册表中的内容主

利用java.util.prefs包操作windows注册表

利用java.util.prefs包操作windows注册表 Java 操作windows注册表,主要的API 主要接口 接口 说明 NodeChangeListener 用于接收首选项节点更改事件的侦听器. PreferenceChangeListener 用于接收首选项节点更改事件的侦听器. PreferencesFactory 生成Preferences对象的factory对象. 主要的类 类 说明 AbstractPreferences 此类提供了Preferences类的骨干实现,从而

windows注册表编程

Windows注册表 1 注册表的作用 注册表在windows中非常重要,它是一个庞大的数据库,里面保存了大量的系统信息,例如保存软件硬件的配置信息,计算机系统的设置,性能记录. 如果注册表遭到破坏,就可能对整个系统造成影响,甚至系统瘫痪. 2 注册表的结构 注册表是树状的层次结构:主键-->子键-->子键-->子键-->---->键值.其中每一个键都有键值,键值由3部分构成:值名,值类型,值本身值.有点像int x =0的节奏哈. 每个键都有一个默认的值,所以的默认值就是说

详解Windows注册表分析取证

大多数都知道windows系统中有个叫注册表的东西,但却很少有人会去深入的了解它的作用以及如何对它进行操作.然而对于计算机取证人员来说注册表无疑是块巨大的宝藏.通过注册表取证人员能分析出系统发生了什么,发生的时间以及如何发生的等.在本文中我将为大家详细介绍Windows注册表的工作原理,以及如何对收集用户留下的各类指纹信息. 什么是注册表? 注册表是用于存储Windows系统用户,硬件和软件的存储配置信息的数据库.虽然注册表是为了配置系统而设计的,但它可以跟踪用户的活动,连接到系统的设备,什么时

Java 修改Windows注册表，以实现开机自启动应用程序。

使用Java修改Windows注册表,使用最基本的就是cmd命令. 事例和运行结果如下所示: package day01; import java.io.IOException; /* 1,reg add 将新的子项或项添加到注册表中 语法:reg add KeyName [/v EntryName|/ve] [/t DataType] [/s separator] [/d value] [/f] 参数 KeyName 指定子项的完全路径.对于远程计算机,请在\\ComputerName\Pat

一次Windows 注册表中注册表项目丢失导致的Oracle 数据库启动问题。

一次Windows  注册表中注册表项目丢失导致的Oracle 数据库启动问题. 环境说明: 1.windows 2008操作系统 x64bit 2.Oracle database 11.2.0.1 32bit 3.sqlplus / as sysdba进不去,报错: c:\user\administrator>sqlplus / as sysdba Error 6 initializing SQL*Plus Message file sp1<lang>.msb not found SP