Исходник LiteRegedit

[SR_team]

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

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

• lpName - Имя ключа (аля индекс массива).
• dwType - Тип записываемого в ключ значения (можно взять отсюда).
  • Чтение. Для значений, которые не являются строковыми и REG_NONE, размер определяется автоматически, если в maxSize указать 0.
  • Запись. Для значений, которые не являются REG_NONE, размер определяется автоматически, если в size указать 0.
• outBuf - Указатель на переменную (массив) в которую будет записано значение.
• inBuf - Указатель на переменную (массив) из которой будет взято значение.
• maxSize - Максимально допустимый размер переменной (массива).
• size - Размер переменной (массива).
• hKey - Раздел реестра (можно взять отсюда).
  
• lpSubKey - Путь к нужной ветке реестра, относительно раздела.

Спойлер: Код класса

#include <windows.h>
#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;
    }
};

Спойлер: Пример использования

#include <iostream>
#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 << buf << std::endl;
        }
    }

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

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

    getchar();
    return 0;
}

 

[SR_team]

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

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]

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