LiteRegedit

[SR_team]

Написал совсем не большой класс для работы с реестром. Это удобнее, чем использовать процедурные функции WinApi.

Класс позволяет писать, читать, удалять значения из ветки реестра.

Немного о параметрах


lpName- Имя ключа (аля индекс массива).

dwType- Тип записываемого в ключ значения (можно взять отсюда (https://www.blast.hk/redirect/aHR0cHM6Ly9tc2RuLm1pY3Jvc29mdC5jb20vcnUtcnUvbGlicm FyeS93aW5kb3dzL2Rlc2t0b3AvbXM3MjQ4ODQodj12cy44NSku YXNweA)).
Чтение. Для значений, которые не являются строковыми и REG_NONE, размер определяется автоматически, если в maxSize указать 0.

Запись. Для значений, которые не являются REG_NONE, размер определяется автоматически, если в size указать 0.


outBuf- Указатель на переменную (массив) в которую будет записано значение.

inBuf- Указатель на переменную (массив) из которой будет взято значение.

maxSize- Максимально допустимый размер переменной (массива).

size- Размер переменной (массива).

hKey- Раздел реестра (можно взять отсюда (https://www.blast.hk/redirect/aHR0cHM6Ly9tc2RuLm1pY3Jvc29mdC5jb20vcnUtcnUvbGlicm FyeS93aW5kb3dzL2Rlc2t0b3AvbXM3MjQ4MzYodj12cy44NSku YXNweA)).

lpSubKey- Путь к нужной ветке реестра, относительно раздела.





C++:






#include
#pragma comment (lib, "advapi32")
// Registry Value Types
// https://msdn.microsoft.com/ru-ru/library/windows/desktop/ms724884(v=vs.85).aspx
class
CLiteRegedit
{
public
:
CLiteRegedit
(
HKEY hKey
,
LPCSTR lpSubKey
)
{
_hKey
=
0
;
RegCreateKeyExA
(
hKey
,
lpSubKey
,
0
,
NULL
,
REG_OPTION_NON_VOLATILE
,
KEY_ALL_ACCESS
,
NULL
,
&
_hKey
,
NULL
)
;
}
~
CLiteRegedit
(
)
{
if
(
_hKey
!=
NULL
)
RegCloseKey
(
_hKey
)
;
}
bool
GetRegister
(
LPCSTR lpName
,
DWORD dwType
,
void
*
outBuf
,
DWORD maxSize
=
0
)
{
if
(
outBuf
==
nullptr
||
_hKey
==
NULL
)
return
false
;
if
(
!
strlen
(
lpName
)
)
return
false
;
if
(
!
AutoSizeRead
(
dwType
,
outBuf
,
maxSize
)
)
return
false
;
return
!
RegQueryValueExA
(
_hKey
,
lpName
,
NULL
,
&
dwType
,
(
byte
*
)
outBuf
,
&
maxSize
)
;
}
bool
SetRegister
(
LPCSTR lpName
,
DWORD dwType
,
void
*
inBuf
,
DWORD size
=
0
)
{
if
(
inBuf
==
nullptr
||
_hKey
==
NULL
)
return
false
;
if
(
!
strlen
(
lpName
)
)
return
false
;
if
(
!
AutoSizeWrite
(
dwType
,
inBuf
,
size
)
)
return
false
;
return
!
RegSetValueExA
(
_hKey
,
lpName
,
0
,
dwType
,
(
byte
*
)
inBuf
,
size
)
;
}
bool
GetRegisterDefault
(
LPSTR outBuf
,
LONG maxSize
)
{
if
(
outBuf
==
nullptr
||
_hKey
==
NULL
)
return
false
;
return
!
RegQueryValueA
(
_hKey
,
NULL
,
(
LPSTR
)
outBuf
,
&
maxSize
)
;
}
bool
SetRegisterDefault
(
LPCSTR inBuf
)
{
if
(
inBuf
==
nullptr
||
_hKey
==
NULL
)
return
false
;
return
!
RegSetValueA
(
_hKey
,
NULL
,
REG_SZ
,
inBuf
,
strlen
(
inBuf
)
)
;
}
bool
DeleteRegister
(
LPCSTR lpName
)
{
if
(
_hKey
==
NULL
)
return
false
;
if
(
!
strlen
(
lpName
)
)
return
false
;
return
!
RegDeleteKeyValueA
(
_hKey
,
NULL
,
lpName
)
;
}
private
:
HKEY _hKey
;
bool
AutoSizeWrite
(
DWORD dwType
,
void
*
inBuf
,
DWORD
&
size
)
{
if
(
!
size
)
{
switch
(
dwType
)
{
case
REG_BINARY
:
size
=
1
;
break
;
case
REG_DWORD
:
case
REG_DWORD_BIG_ENDIAN
:
size
=
4
;
break
;
case
REG_QWORD
:
size
=
8
;
break
;
case
REG_EXPAND_SZ
:
case
REG_LINK
:
case
REG_MULTI_SZ
:
case
REG_SZ
:
size
=
strlen
(
(
LPCSTR
)
inBuf
)
;
break
;
case
REG_NONE
:
default
:
return
false
;
}
}
return
true
;
}
bool
AutoSizeRead
(
DWORD dwType
,
void
*
outBuf
,
DWORD
&
size
)
{
if
(
!
size
)
{
switch
(
dwType
)
{
case
REG_BINARY
:
size
=
1
;
break
;
case
REG_DWORD
:
case
REG_DWORD_BIG_ENDIAN
:
size
=
4
;
break
;
case
REG_QWORD
:
size
=
8
;
break
;
case
REG_EXPAND_SZ
:
case
REG_LINK
:
case
REG_MULTI_SZ
:
case
REG_SZ
:
case
REG_NONE
:
default
:
return
false
;
}
}
return
true
;
}
}
;









C++:





[CODE]
#include
#include "LiteRegedit.hpp"
int
main
(
)
{
CLiteRegedit
*
reg
=
new
CLiteRegedit
(
HKEY_CURRENT_USER
,
"Software\\Test"
)
;
if
(
reg
->
SetRegisterDefault
(
"Ahuenno!!!"
)
)
{
char
buf
[
256
]
;
if
(
reg
->
GetRegisterDefault
(
buf
,
256
)
)
{
std
::
cout

SetRegister
(
"Reg1"
,
REG_DWORD
,
&
dwValue
)
)
{
dwValue
=
0
;
if
(
reg
->
GetRegister
(
"Reg1"
,
REG_DWORD
,
&
dwValue
)
)
{
std
::
cout

SetRegister
(
"Nick"
,
REG_SZ
,
szNick
,
strlen
(
szNick
)
)
)
{
char
buf
[
256
]
;
if
(
reg
->
GetRegister
(
"Nick"
,
REG_SZ
,
buf
,
256
)
)
{
std
::
cout



https://dl.prime-hack.net/10bo44y01t9xyf.png

[SR_team]

Наследник, для упрощения работы с распространенными типами данных

C++:






class
CLiteRegeditEasy
:
public
CLiteRegedit
{
public
:
CLiteRegeditEasy
(
HKEY hKey
,
LPCSTR lpSubKey
)
:
CLiteRegedit
(
hKey
,
lpSubKey
)
{
no_error
=
true
;
}
void
WriteString
(
LPCSTR lpName
,
LPSTR lpString
,
.
.
.
)
{
va_list ap
;
char
*
szStr
=
new
char
[
strlen
(
lpString
)
*
2
+
1024
]
;
va_start
(
ap
,
lpString
)
;
vsprintf
(
szStr
,
lpString
,
ap
)
;
va_end
(
ap
)
;
no_error
=
SetRegister
(
lpName
,
REG_SZ
,
szStr
,
strlen
(
szStr
)
)
;
delete
[
]
szStr
;
}
std
::
string
ReadString
(
LPCSTR lpName
)
{
char
szStr
[
0x1000
]
;
no_error
=
GetRegister
(
lpName
,
REG_SZ
,
szStr
,
0x1000
)
;
return
szStr
;
}
void
WriteInteger
(
LPCSTR lpName
,
int
value
)
{
no_error
=
GetRegister
(
lpName
,
REG_DWORD
,
&
value
)
;
}
int
ReadInteger
(
LPCSTR lpName
)
{
int
value
;
no_error
=
GetRegister
(
lpName
,
REG_DWORD
,
&
value
)
;
return
value
;
}
void
WriteFloat
(
LPCSTR lpName
,
float
value
)
{
no_error
=
GetRegister
(
lpName
,
REG_DWORD
,
&
value
)
;
}
float
ReadFloat
(
LPCSTR lpName
)
{
float
value
;
no_error
=
GetRegister
(
lpName
,
REG_DWORD
,
&
value
)
;
return
value
;
}
void
WriteLongLong
(
LPCSTR lpName
,
long
long
value
)
{
no_error
=
GetRegister
(
lpName
,
REG_QWORD
,
&
value
)
;
}
long
long
ReadLongLong
(
LPCSTR lpName
)
{
long
long
value
;
no_error
=
GetRegister
(
lpName
,
REG_QWORD
,
&
value
)
;
return
value
;
}
void
WriteDouble
(
LPCSTR lpName
,
double
value
)
{
no_error
=
GetRegister
(
lpName
,
REG_QWORD
,
&
value
)
;
}
double
ReadDouble
(
LPCSTR lpName
)
{
double
value
;
no_error
=
GetRegister
(
lpName
,
REG_QWORD
,
&
value
)
;
return
value
;
}
bool
IsError
(
)
{
return
!
no_error
;
}
private
:
bool
no_error
;
}
;

[iAmerican]

наконец тааа , Спасибо