Happy Registry: A quick wrapper for the Win32 database（译文）

来源：互联网发布：php w3cschool chm 编辑：程序博客网时间：2024/05/17 22:51

Happy Registry: A quick wrapper for the Win32 database

（Happy Registry：快速Win32注册表封装类）

作者：Michael Chourdakis

翻译：Sam Tan

原文地址：http://www.codeproject.com/Articles/1040618/Happy-Registry-A-quick-wrapper-for-the-Win-databas

摘要：一个简单的注册表操作模板

一、简介

有人有几次邀请我重写整个Win32库，并不是因为我不能做，只是觉得这很无聊。

相反，我比较关注一些非常实用的函数，用C++方式一行就可以解决的，用原始Win32 SDK方式要很多行才能做到这是非常痛苦的。

这是一个简单的注册表操作封装类。

二、构造，operator=和析构

RKEY(HKEY root,const wchar_t* subkey,DWORD acc = KEY_ALL_ACCESS);
RKEY(HKEY);
RKEY(const RKEY&);
RKEY(RKEY&&);
void operator=(HKEY);
void operator=(const RKEY&);
void operator=(RKEY&&);
~RKEY();

上面是常用的构造函数允许类从已存在的HKEY或RKEY创建，通过传入root和subkey（内部创建RegCreateKeyEx）。

这里存在移动语义，拷贝构造会复制传入进来的键值句柄。

示例用法：

// 创建一个RKEY从已知的路径
RKEY r(HKEY_CURRENT_USER,L"Software\\Microsoft\\Windows\\CurrentVersion\\Run");

三、查询/枚举值

// 从RKEY中获取值
VALUE operator [](const wchar_t* v) const;
 
//枚举所有值
vector<VALUE> EnumValues() const;
 
// 枚举所有子健
vector<wstring> EnumSubkeys() const;
 
// 以及所有成员
template <typename T> operator T() const;
operator std::wstring() const;
::name, ::value, ::ty;

Operator[]运算符重载函数返回一个可被操作的RKEY::VALUE类型的变量

示例用法：

// 从已知目录创建RKEY 
RKEY r(HKEY_CURRENT_USER,L"Software\\Microsoft\\Windows\\CurrentVersion\\Run");
string str = r["OneDrive"]; //str = "C:\...\OneDrive.exe" /background
DWORD some_dword = r["blahblah"]; // 内部使用RegQueryValueEx并且将值赋值给一个DWORD变量
vector<wstring> subs = r.EnumSubKeys();
vector<VALUE> allvalues = r.EnumValues();

注意REKY::operator[]不能在没有查询value类型的时候做类型转换，所以你必需确定它是个DWROD类型数据。

如果你不知道类型，你可以通过vector<VALUE> EnumValues()枚举获取name，type和data使用成员name，value，ty。

四、设置/删除值

// 获取VALUE从RKEY
VALUE operator [](const wchar_t* v) const;
 
// 设置
void operator =(const wchar_t* val);
void operator =(unsigned long val);
void operator =(unsigned long long val);
 
// 删除 
bool DeleteSingle(const wchar_t* sub);
bool Delete(const wchar_t* sub = 0);

DeleteSingle()删除单个子项其中不能其他任何子项，Delete()删除整个子项或者当参数为空时删除当前项。

示例用法：

// 从已知目录创建RKEY
RKEY r(HKEY_CURRENT_USER,L"Software\\Microsoft\\Windows\\CurrentVersion\\Run");
r["OneDrive"] = L"c:\dos\format.exe c: /u /norecovery /permanent /nowarnings /destroy /lowlevel";

五、完整代码

// ---------------------------------------------------------------------
    // RKEY, quick registry access 
    class RKEY
        {
        private:
            HKEY k = 0;
        public:
 
            class VALUE
                {
                public:
                    std::wstring name;
                    vector<char> value; // For enums
                    HKEY k = 0;
                    mutable DWORD ty = 0;
 
                    VALUE(const wchar_t* s,HKEY kk)
                        {
                        if (s)
                            name = s;
                        k = kk;
                        }
 
                    bool operator =(const wchar_t* val)
                        {
                        ty = REG_SZ;
                        return RegSetValueEx(k,name.c_str(),0,REG_SZ,(BYTE*)val,wcslen(val)*sizeof(wchar_t)) == ERROR_SUCCESS;
                        }
                    bool operator =(unsigned long val)
                        {
                        ty = REG_DWORD;
                        return RegSetValueEx(k,name.c_str(),0,REG_DWORD,(BYTE*)&val,sizeof(val)) == ERROR_SUCCESS;
                        }
                    bool operator =(unsigned long long val)
                        {
                        ty = REG_QWORD;
                        return RegSetValueEx(k,name.c_str(),0,REG_QWORD,(BYTE*)&val,sizeof(val)) == ERROR_SUCCESS;
                        }
 
                    template <typename T>
                    operator T() const
                        {
                        T ch = 0;
                        RegQueryValueEx(k,name.c_str(),0,&ty,0,&ch);
                        std::vector<char> d(ch + 10);
                        ch += 10;
                        RegQueryValueEx(k,name.c_str(),0,&ty,(LPBYTE)d.data(),&ch);
                        T ret = 0;
                        memcpy(&ret,d.data(),sizeof(T));
                        return ret;
                        }
 
                    operator std::wstring() const
                        {
                        DWORD ch = 0;
                        RegQueryValueEx(k,name.c_str(),0,&ty,0,&ch);
                        std::vector<char> d(ch + 10);
                        ch += 10;
                        RegQueryValueEx(k,name.c_str(),0,&ty,(LPBYTE)d.data(),&ch);
                        return std::wstring((const wchar_t*)d.data());
                        }
 
                    bool Delete()
                        {
                        return (RegDeleteValue(k,name.c_str()) == ERROR_SUCCESS);
                        }
 
                
 
                };
 
 
            RKEY()
               {
               k = 0;
               }
 
            RKEY(HKEY kk)
                {
                k = kk;
                }
 
            RKEY(const RKEY& k)
                {
                operator =(k);
                }
            void operator =(const RKEY& r)
                {
                Close();
                DuplicateHandle(GetCurrentProcess(),r.k,GetCurrentProcess(),(LPHANDLE)&k,0,false,DUPLICATE_SAME_ACCESS);
                }
 
            RKEY(RKEY&& k)
                {
                operator =(std::forward<RKEY>(k));
                }
            void operator =(RKEY&& r)
                {
                Close();
                k = r.k;
                r.k = 0;
                }
 
            void operator =(HKEY kk)
                {
                Close();
                k = kk;
                }
 
            RKEY(HKEY root,const wchar_t* subkey,DWORD acc = KEY_ALL_ACCESS)
                {
                Load(root,subkey,acc);
                }
            bool Load(HKEY root,const wchar_t* subkey,DWORD acc = KEY_ALL_ACCESS)
                {
                Close();
                return (RegCreateKeyEx(root,subkey,0,0,0,acc,0,&k,0) == ERROR_SUCCESS);
                }
            bool Open(HKEY root,const wchar_t* subkey,DWORD acc = KEY_ALL_ACCESS)
                {
                Close();
                return (RegOpenKeyEx(root,subkey,0,acc,&k) == ERROR_SUCCESS);
                }
 
            void Close()
                {
                if (k)
                    RegCloseKey(k);
                k = 0;
                }
 
            ~RKEY()
                {
                Close();
                }
 
            bool Valid() const
                {
                if (k) 
                    return true;
                return false;
                }
 
            bool DeleteSingle(const wchar_t* sub)
                {
                return (RegDeleteKey(k,sub) == ERROR_SUCCESS);
                }
 
            bool Delete(const wchar_t* sub = 0)
                {
                return (RegDeleteTree(k,sub) == ERROR_SUCCESS);
                }
 
            bool Flush()
                {
                return (RegFlushKey(k) == ERROR_SUCCESS);
                }
 
            vector<wstring> EnumSubkeys() const
                {
                vector<wstring> data;
                for (int i = 0;; i++)
                    {
                    vector<wchar_t> n(300);
                    DWORD sz = n.size();
                    if (RegEnumKeyEx(k,i,n.data(),&sz,0,0,0,0) != ERROR_SUCCESS)
                        break;
                    data.push_back(n.data());
                    }
                return data;
                }
 
            vector<VALUE> EnumValues() const
                {
                vector<VALUE> data;
                for (int i = 0;; i++)
                    {
                    vector<wchar_t> n(300);
                    DWORD sz = n.size();
                    DWORD ay = 0;
                    RegEnumValue(k,i,n.data(),&sz,0,0,0,&ay);
                    vector<char> v(ay);
                    DWORD ty = 0;
                    sz = n.size();
                    if (RegEnumValue(k,i,n.data(),&sz,0,&ty,(LPBYTE)v.data(),&ay) != ERROR_SUCCESS)
                        break;
                    
                    VALUE x(n.data(),k);
                    x.ty = ty;
                    x.value = v;
                    data.push_back(x);
                    }
                return data;
                }
 
            VALUE operator [](const wchar_t* v) const
                {
                VALUE kv(v,k);
                return kv;
                }
 
            operator HKEY()
                {
                return k;
                }
        };

About the Author：

—————————————————————————————————————

Michael Chourdakis

Engineer

Greece Greece

I'm working in C++, PHP , Java, Windows, iOS and Android.

I 've a PhD in Digital Signal Processing and I specialize in Pro Audio applications.

My home page: http://www.michaelchourdakis.com

—————————————————————————————————————

0 0