【分享】一个c++ 模板，支持 宽字节多字节的注册表操作类

欢迎加入我们的QQ群，无论你是否工作，学生，只要有c / vc / c++ 编程经验，就来吧！158427611 

通过模板特化的方式，实现uniface和多字节的接口配置

使用到c++11 function bind

#pragma once

#include <string>
#include <functional>

#include <windows.h>

namespace RegKey
{
    enum Name
    {
        CLASSES_ROOT,
        CURRENT_USER,
        LOCAL_MACHINE,
        USERS,
        CURRENT_CONFIG
    };

}



template<class T_CHAR>
class Regediter
{
public:
    typedef const T_CHAR*   TCAHR_PTR;

    struct KeyUtils
    {
        KeyUtils(){ key = 0; }
        ~KeyUtils() { if (key) ::RegCloseKey(key); }
        
        operator PHKEY(){ return &key; }
        operator HKEY(){ return key; }

        HKEY key;
    };

    Regediter(RegKey::Name k);

    ~Regediter(){}

    //选择根键
    void Select(RegKey::Name nKey)
    {
        switch (nKey)
        {
        case RegKey::CLASSES_ROOT:
            m_rootKey.key = HKEY_CLASSES_ROOT;
            break;
        case RegKey::LOCAL_MACHINE:
            m_rootKey.key = HKEY_LOCAL_MACHINE;
            break;
        case RegKey::USERS:
            m_rootKey.key = HKEY_USERS;
            break;
        case RegKey::CURRENT_CONFIG:
            m_rootKey.key = HKEY_CURRENT_CONFIG;
            break;
        case RegKey::CURRENT_USER:
        default:
            m_rootKey.key = HKEY_CURRENT_USER;
            break;
        }
    }
    
    bool CreateKey(TCAHR_PTR keyPath, TCAHR_PTR keyName)
    {
        KeyUtils hKey;
        if (ERROR_SUCCESS != reg_open_key(m_rootKey, keyPath, 0, KEY_SET_VALUE | KEY_WOW64_64KEY, hKey))
            return false;

        KeyUtils hNextKey;
        return (ERROR_SUCCESS == reg_create_key(hKey, keyName, hNextKey));
    }

    bool Regediter::CreateString(TCAHR_PTR keyPath, TCAHR_PTR keyName, TCAHR_PTR keyValue, DWORD len)
    {
        KeyUtils hKey;
        if (ERROR_SUCCESS != reg_open_key(m_rootKey, keyPath, 0, KEY_SET_VALUE | KEY_WOW64_64KEY, hKey))
            return false;

        return (ERROR_SUCCESS == reg_set_value(hKey, keyName, 0, REG_SZ, (const BYTE*)keyValue, len));
    }

    bool Regediter::CreateStringEx(TCAHR_PTR keyPath, TCAHR_PTR keyName, const std::basic_string<T_CHAR, std::char_traits<T_CHAR>, std::allocator<T_CHAR> >& value)
    {
        return CreateString(keyPath, keyName, value.c_str(), value.length());
    }

    bool Regediter::CreateValue(TCAHR_PTR keyPath, TCAHR_PTR keyName, DWORD value)
    {
        KeyUtils hKey;
        if (ERROR_SUCCESS != reg_open_key(m_rootKey, keyPath, 0, KEY_SET_VALUE | KEY_WOW64_64KEY, hKey))
            return false;

        return (ERROR_SUCCESS == reg_set_value(hKey, keyName, 0, REG_DWORD, (const BYTE*)&value, sizeof(DWORD)));
    }

    bool Regediter::DeleteValue(TCAHR_PTR keyPath, TCAHR_PTR keyName)
    {
        KeyUtils hKey;
        if (ERROR_SUCCESS != reg_open_key(m_rootKey, keyPath, 0, KEY_SET_VALUE | KEY_WOW64_64KEY, hKey))
            return false;

        return (ERROR_SUCCESS == reg_delete_key(hKey, keyName));
    }

    bool Regediter::GetString(TCAHR_PTR keyPath, TCAHR_PTR keyName, T_CHAR* value, DWORD& len)
    {
        KeyUtils hKey;
        if (ERROR_SUCCESS != reg_open_key(m_rootKey, keyPath, 0, KEY_READ | KEY_WOW64_64KEY, hKey))
            return false;

        DWORD dwType = REG_SZ;
        return (ERROR_SUCCESS == reg_query_value(hKey, keyName, 0, &dwType, (LPBYTE)&value, &len));
    }

    bool Regediter::GetStringEx(TCAHR_PTR keyPath, TCAHR_PTR keyName, std::basic_string<T_CHAR, std::char_traits<T_CHAR>, std::allocator<T_CHAR> >& value)
    {
        KeyUtils hKey;
        if (ERROR_SUCCESS != reg_open_key(m_rootKey, keyPath, 0, KEY_READ | KEY_WOW64_64KEY, hKey))
            return false;

        DWORD dwKeyValueSize = 1024;
        T_CHAR buffer[1024] = { 0 };
        DWORD dwType = REG_BINARY;
        if (ERROR_SUCCESS == reg_query_value(hKey, key, 0, &dwType, (LPBYTE)buffer, &dwKeyValueSize))
        {
            value = buffer;
            return true;
        }

        return false;
    }

    bool Regediter::GetValue(TCAHR_PTR keyPath, TCAHR_PTR keyName, DWORD& value)
    {
        KeyUtils hKey;
        if (ERROR_SUCCESS != reg_open_key(m_rootKey, keyPath, 0, KEY_READ | KEY_WOW64_64KEY, hKey))
            return false;

        DWORD dwGetValue = 0;
        DWORD dwSize = sizeof(DWORD);
        DWORD dwType = REG_DWORD;
        if (ERROR_SUCCESS == reg_query_value(hKey, keyName, 0, &dwType, (LPBYTE)&dwGetValue, &dwSize))
        {
            value = dwGetValue;
            return true;
        }

        return false;
    }

    bool Regediter::GetData(TCAHR_PTR keyPath, TCAHR_PTR keyName, BYTE* value, DWORD& len)
    {
        KeyUtils hKey;
        if (ERROR_SUCCESS != reg_open_key(m_rootKey, keyPath, 0, KEY_READ | KEY_WOW64_64KEY, hKey))
            return false;

        DWORD dwType = REG_BINARY;
        return if (ERROR_SUCCESS == reg_query_value(hKey, keyName, 0, &dwType, (LPBYTE), , &len));
    }

    bool Regediter::BackupKey(TCAHR_PTR keyPath, TCAHR_PTR fileName)
    {
        HANDLE hToken;
        TOKEN_PRIVILEGES tkp;
        if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken))
        {
            return false;
        }

        LookupPrivilegeValue(NULL, SE_BACKUP_NAME, &tkp.Privileges[0].Luid);
        tkp.PrivilegeCount = 1;
        tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
        AdjustTokenPrivileges(hToken, FALSE, &tkp, 0, (PTOKEN_PRIVILEGES)NULL, 0);
        int b = GetLastError();

        KeyUtils hKey;
        if (ERROR_SUCCESS != reg_open_key(m_rootKey, keyPath, 0, KEY_SET_VALUE | KEY_WOW64_64KEY, hKey))
            return false;

        return (ERROR_SUCCESS != reg_save_to_file(hKey, fileName, NULL));
    }

    bool Regediter::RestoreKey(TCAHR_PTR keyPath, TCAHR_PTR fileName, bool isSure)
    {
        HANDLE hToken;
        TOKEN_PRIVILEGES tkp;
        if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken))
        {
            return false;
        }

        LookupPrivilegeValue(NULL, SE_RESTORE_NAME, &tkp.Privileges[0].Luid);
        tkp.PrivilegeCount = 1;
        tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
        AdjustTokenPrivileges(hToken, FALSE, &tkp, 0, (PTOKEN_PRIVILEGES)NULL, 0);

        KeyUtils hKey;
        if (ERROR_SUCCESS != reg_open_key(m_rootKey, path, 0, KEY_SET_VALUE | KEY_WOW64_64KEY, hKey))
            return false;

        DWORD dwFlag;
        if (isSure)
        {
            dwFlag = REG_FORCE_RESTORE;
        }
        else
        {
            dwFlag = REG_WHOLE_HIVE_VOLATILE;
        }

        return (ERROR_SUCCESS != reg_restore_from_file(hKey, fileName, dwFlag));
    }

    bool Regediter::DeleteKey(TCAHR_PTR keyPath, TCAHR_PTR keyName)
    {
        KeyUtils hKey;
        if (ERROR_SUCCESS != reg_open_key(m_rootKey, path, 0, KEY_SET_VALUE | KEY_WOW64_64KEY, hKey))
            return false;

        return (ERROR_SUCCESS == reg_delete_key(hKey, keyName));
    }
    
protected:
    KeyUtils m_rootKey;

    std::function<LSTATUS(HKEY, TCAHR_PTR, DWORD, REGSAM, PHKEY)>              reg_open_key;
    std::function<LSTATUS(HKEY, TCAHR_PTR, PHKEY)>                             reg_create_key;
    std::function<LSTATUS(HKEY, TCAHR_PTR, DWORD, DWORD, const BYTE*, DWORD)>  reg_set_value;
    std::function<LSTATUS(HKEY, TCAHR_PTR)>                                    reg_delete_key;
    std::function<LSTATUS(HKEY, TCAHR_PTR, LPDWORD, LPDWORD, LPBYTE, LPDWORD)> reg_query_value;

    std::function<LSTATUS(HKEY, TCAHR_PTR, LPSECURITY_ATTRIBUTES)>             reg_save_to_file;
    std::function<LSTATUS(HKEY, TCAHR_PTR, DWORD)>                             reg_restore_from_file;

};

template<>
Regediter<char>::Regediter(RegKey::Name k)
{
    reg_open_key = std::bind(RegOpenKeyExA, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4, std::placeholders::_5);
    reg_create_key = std::bind(RegCreateKeyA, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
    reg_set_value = std::bind(RegSetValueExA, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4, std::placeholders::_5, std::placeholders::_6);
    reg_delete_key = std::bind(RegDeleteValueA, std::placeholders::_1, std::placeholders::_2);
    reg_query_value = std::bind(RegQueryValueExA, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4, std::placeholders::_5, std::placeholders::_6);

    reg_save_to_file = std::bind(RegSaveKeyA, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
    reg_restore_from_file = std::bind(RegRestoreKeyA, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);

    Select(k);
}


template<>
Regediter<wchar_t>::Regediter(RegKey::Name k)
{
    reg_open_key = std::bind(RegOpenKeyExW, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4, std::placeholders::_5);
    reg_create_key = std::bind(RegCreateKeyW, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
    reg_set_value = std::bind(RegSetValueExW, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4, std::placeholders::_5, std::placeholders::_6);
    reg_delete_key = std::bind(RegDeleteValueW, std::placeholders::_1, std::placeholders::_2);
    reg_query_value = std::bind(RegQueryValueExW, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4, std::placeholders::_5, std::placeholders::_6);

    reg_save_to_file = std::bind(RegSaveKeyW, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
    reg_restore_from_file = std::bind(RegRestoreKeyW, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);

    Select(k);
}