第17章注册表与配置文件

课程目录第17章注册表与配置文件

17. 注册表与配置文件：Windows注册表封装、Linux gsettings、跨平台配置中心

说实话，跨平台开发里最让人头疼的，就是配置存储。

Windows 有注册表，Linux 有 gsettings，macOS 还有 UserDefaults。每个平台都有自己的「小算盘」。你写一个应用，总不能给 Windows 用户用注册表，给 Linux 用户说「你去改 XML 吧」？

嗯，这章我们就来解决这个问题。

我会带你封装一套统一的配置接口，底层分别对接 Windows 注册表和 Linux gsettings。上层调用者根本不用关心数据存在哪——这就是跨平台配置中心的核心思想。

17.1 Windows 注册表封装

先聊聊 Windows 注册表。这东西历史悠久，从 Windows 3.1 就有了。我刚开始做 Windows 开发时，觉得注册表就是个黑箱，动不动就 regedit 进去乱翻。后来吃过亏——有一次不小心删了某个键值，导致整个 IDE 打不开。嗯，从那以后我就老老实实写封装了。

注册表的结构其实很简单：

根键：HKEY_CURRENT_USER、HKEY_LOCAL_MACHINE 等
路径：类似文件系统的目录结构
键值：名称 + 数据（字符串、DWORD、二进制等）

我们封装的目标是：让 C++ 代码像读写配置文件一样操作注册表。

核心原则：只操作 HKEY_CURRENT_USER，别碰 HKEY_LOCAL_MACHINE。前者是用户级，不需要管理员权限；后者是系统级，搞不好就蓝屏。

来看一个我常用的封装类：

class WindowsRegistry {
public:
    // 打开或创建键
    bool OpenKey(const std::wstring& subKey, bool createIfNotExist = true) {
        HKEY hKey;
        LSTATUS status = RegOpenKeyExW(
            HKEY_CURRENT_USER,
            subKey.c_str(),
            0,
            KEY_READ | KEY_WRITE,
            &hKey
        );
        
        if (status != ERROR_SUCCESS && createIfNotExist) {
            // 键不存在，创建它
            status = RegCreateKeyExW(
                HKEY_CURRENT_USER,
                subKey.c_str(),
                0,
                nullptr,
                REG_OPTION_NON_VOLATILE,
                KEY_READ | KEY_WRITE,
                nullptr,
                &hKey,
                nullptr
            );
        }
        
        if (status == ERROR_SUCCESS) {
            m_hKey = hKey;
            return true;
        }
        return false;
    }
    
    // 读取字符串值
    std::wstring GetString(const std::wstring& name, 
                           const std::wstring& defaultValue = L"") {
        if (!m_hKey) return defaultValue;
        
        WCHAR buffer[1024];
        DWORD bufferSize = sizeof(buffer);
        DWORD type = 0;
        
        LSTATUS status = RegQueryValueExW(
            m_hKey, name.c_str(), nullptr,
            &type, (LPBYTE)buffer, &bufferSize
        );
        
        if (status == ERROR_SUCCESS && type == REG_SZ) {
            return buffer;
        }
        return defaultValue;
    }
    
    // 写入字符串值
    bool SetString(const std::wstring& name, const std::wstring& value) {
        if (!m_hKey) return false;
        
        LSTATUS status = RegSetValueExW(
            m_hKey, name.c_str(), 0,
            REG_SZ,
            (const BYTE*)value.c_str(),
            (value.size() + 1) * sizeof(WCHAR)
        );
        return status == ERROR_SUCCESS;
    }
    
    // 读取 DWORD（整数）
    DWORD GetDWORD(const std::wstring& name, DWORD defaultValue = 0) {
        if (!m_hKey) return defaultValue;
        
        DWORD value = 0;
        DWORD valueSize = sizeof(value);
        DWORD type = 0;
        
        LSTATUS status = RegQueryValueExW(
            m_hKey, name.c_str(), nullptr,
            &type, (LPBYTE)&value, &valueSize
        );
        
        if (status == ERROR_SUCCESS && type == REG_DWORD) {
            return value;
        }
        return defaultValue;
    }
    
    // 写入 DWORD
    bool SetDWORD(const std::wstring& name, DWORD value) {
        if (!m_hKey) return false;
        
        LSTATUS status = RegSetValueExW(
            m_hKey, name.c_str(), 0,
            REG_DWORD,
            (const BYTE*)&value, sizeof(value)
        );
        return status == ERROR_SUCCESS;
    }
    
    ~WindowsRegistry() {
        if (m_hKey) {
            RegCloseKey(m_hKey);
        }
    }
    
private:
    HKEY m_hKey = nullptr;
};

避坑指南：我曾经在读取注册表时忘了检查 type 字段，结果读到了一个 REG_DWORD 却按字符串解析，程序直接崩溃。记住：RegQueryValueExW 返回的 type 一定要校验。

17.2 Linux gsettings 封装

到了 Linux 这边，情况就完全不同了。Linux 桌面环境（GNOME）用的是 gsettings，底层基于 dconf。说白了，它就是个键值对数据库，但比注册表清爽得多。

gsettings 的操作模式是：

Schema：定义配置的结构（类似数据库表）
Key：具体的配置项
Value：值（支持字符串、整数、布尔、数组等）

不过 gsettings 的 C API 有点啰嗦。我习惯封装一个简洁的 C++ 类：

#include <gio/gio.h>

class GSettingsConfig {
public:
    GSettingsConfig(const std::string& schemaId) {
        m_settings = g_settings_new(schemaId.c_str());
        if (!m_settings) {
            throw std::runtime_error("Failed to create GSettings: " + schemaId);
        }
    }
    
    std::string GetString(const std::string& key, 
                          const std::string& defaultValue = "") {
        if (!m_settings) return defaultValue;
        
        gchar* value = g_settings_get_string(m_settings, key.c_str());
        if (value) {
            std::string result(value);
            g_free(value);
            return result;
        }
        return defaultValue;
    }
    
    bool SetString(const std::string& key, const std::string& value) {
        if (!m_settings) return false;
        return g_settings_set_string(m_settings, key.c_str(), value.c_str());
    }
    
    int GetInt(const std::string& key, int defaultValue = 0) {
        if (!m_settings) return defaultValue;
        return g_settings_get_int(m_settings, key.c_str());
    }
    
    bool SetInt(const std::string& key, int value) {
        if (!m_settings) return false;
        return g_settings_set_int(m_settings, key.c_str(), value);
    }
    
    bool GetBool(const std::string& key, bool defaultValue = false) {
        if (!m_settings) return defaultValue;
        return g_settings_get_boolean(m_settings, key.c_str());
    }
    
    bool SetBool(const std::string& key, bool value) {
        if (!m_settings) return false;
        return g_settings_set_boolean(m_settings, key.c_str(), value);
    }
    
    ~GSettingsConfig() {
        if (m_settings) {
            g_object_unref(m_settings);
        }
    }
    
private:
    GSettings* m_settings = nullptr;
};

注意：gsettings 要求先安装 schema 文件（.gschema.xml），否则 g_settings_new 会失败。我遇到过部署时忘了打包 schema，结果程序启动就崩溃的惨案。记得在 CMakeLists.txt 里加上 schema 安装规则。

17.3 跨平台配置中心

好了，现在两边都有了底层封装。但我们的目标是：上层代码写一次，Windows 和 Linux 都能跑。

怎么做？抽象一个接口，然后根据平台选择实现。这就是策略模式在跨平台开发中的典型应用。

先定义抽象接口：

class IConfigStorage {
public:
    virtual ~IConfigStorage() = default;
    
    virtual std::string GetString(const std::string& key, 
                                   const std::string& defaultValue = "") = 0;
    virtual bool SetString(const std::string& key, 
                           const std::string& value) = 0;
    virtual int GetInt(const std::string& key, int defaultValue = 0) = 0;
    virtual bool SetInt(const std::string& key, int value) = 0;
    virtual bool GetBool(const std::string& key, bool defaultValue = false) = 0;
    virtual bool SetBool(const std::string& key, bool value) = 0;
};

然后实现平台适配器：

#ifdef _WIN32
class ConfigStorage : public IConfigStorage {
public:
    ConfigStorage() {
        // 应用专属路径，比如 "Software\\MyApp"
        m_registry.OpenKey(L"Software\\MyApp", true);
    }
    
    std::string GetString(const std::string& key, 
                           const std::string& defaultValue = "") override {
        std::wstring wKey = ToWide(key);
        std::wstring wValue = m_registry.GetString(wKey, ToWide(defaultValue));
        return ToNarrow(wValue);
    }
    
    bool SetString(const std::string& key, 
                   const std::string& value) override {
        return m_registry.SetString(ToWide(key), ToWide(value));
    }
    
    int GetInt(const std::string& key, int defaultValue = 0) override {
        return static_cast<int>(m_registry.GetDWORD(ToWide(key), 
                                                     static_cast<DWORD>(defaultValue)));
    }
    
    bool SetInt(const std::string& key, int value) override {
        return m_registry.SetDWORD(ToWide(key), static_cast<DWORD>(value));
    }
    
    bool GetBool(const std::string& key, bool defaultValue = false) override {
        return m_registry.GetDWORD(ToWide(key), defaultValue ? 1 : 0) != 0;
    }
    
    bool SetBool(const std::string& key, bool value) override {
        return m_registry.SetDWORD(ToWide(key), value ? 1 : 0);
    }
    
private:
    WindowsRegistry m_registry;
    
    std::wstring ToWide(const std::string& narrow) {
        // 实际项目中用 MultiByteToWideChar 转换
        return std::wstring(narrow.begin(), narrow.end());
    }
    
    std::string ToNarrow(const std::wstring& wide) {
        // 实际项目中用 WideCharToMultiByte 转换
        return std::string(wide.begin(), wide.end());
    }
};

#elif defined(__linux__)
class ConfigStorage : public IConfigStorage {
public:
    ConfigStorage() : m_settings("com.mycompany.myapp") {
        // schema ID 需要和 .gschema.xml 中的 id 一致
    }
    
    std::string GetString(const std::string& key, 
                           const std::string& defaultValue = "") override {
        return m_settings.GetString(key, defaultValue);
    }
    
    bool SetString(const std::string& key, 
                   const std::string& value) override {
        return m_settings.SetString(key, value);
    }
    
    int GetInt(const std::string& key, int defaultValue = 0) override {
        return m_settings.GetInt(key, defaultValue);
    }
    
    bool SetInt(const std::string& key, int value) override {
        return m_settings.SetInt(key, value);
    }
    
    bool GetBool(const std::string& key, bool defaultValue = false) override {
        return m_settings.GetBool(key, defaultValue);
    }
    
    bool SetBool(const std::string& key, bool value) override {
        return m_settings.SetBool(key, value);
    }
    
private:
    GSettingsConfig m_settings;
};
#endif

上层使用就非常简单了：

int main() {
    ConfigStorage config;
    
    // 读写配置，完全不用关心底层平台
    config.SetString("username", "alice");
    config.SetInt("window_width", 1024);
    config.SetBool("dark_mode", true);
    
    std::string name = config.GetString("username", "default_user");
    int width = config.GetInt("window_width", 800);
    bool dark = config.GetBool("dark_mode", false);
    
    return 0;
}

核心思想：把平台差异隔离在底层，上层只面对统一的接口。这样你的业务代码可以跨平台复用，测试也方便——写个 MockConfigStorage 就能跑单元测试。

17.4 架构总览

下面这张图展示了整个配置中心的架构。你看，上层应用只和 IConfigStorage 打交道，底层根据平台自动选择实现。这就是「依赖倒置」原则的实战应用。

17.5 扩展思考

这套架构其实可以继续扩展。比如：

macOS 支持：再加一个 NSUserDefaults 的实现
文件回退：如果注册表或 gsettings 不可用，自动回退到 JSON 文件
配置同步：监听配置变化，实时通知其他模块

我个人习惯在项目里再加一层缓存。每次读配置时先查内存缓存，避免频繁调用系统 API。毕竟注册表和 dconf 的读写速度都不算快。

小技巧：配置变更通知可以用观察者模式实现。Windows 下用 RegNotifyChangeKeyValue，Linux 下用 g_signal_connect 监听 "changed" 信号。这样配置一变，所有相关模块都能立刻感知。

好了，这一章的内容就到这里。配置中心看起来简单，但做好跨平台隔离，能让你的代码少很多 #ifdef 的脏活。记住：接口统一，实现分离，测试方便——这就是跨平台开发的精髓。

公众号:蓝海资料掘金营，微信deep3321

📚 课程目录

17. 注册表与配置文件：Windows注册表封装、Linux gsettings、跨平台配置中心

17.1 Windows 注册表封装

17.2 Linux gsettings 封装

17.3 跨平台配置中心

17.4 架构总览

17.5 扩展思考