如何在C++中使用点运算符定义嵌套调用形式的函数结构

你要的调用形式可以通过嵌套类+公开成员对象的方式实现，核心逻辑是把不同分类的操作封装到不同的内部类中，再在主类暴露对应类的实例作为访问入口。

基础实现示例 #

以下是可直接运行的最小实现：

#include <iostream>

class RegeditAccessor {
public:
    // 封装所有Key相关操作的嵌套类
    class KeyOperator {
    public:
        void Create() {
            // 替换为实际的注册表键创建逻辑
            std::cout << "Regedit.Key.Create() 被调用" << std::endl;
        }
        // 可继续扩展Key的其他方法，比如Delete、Open等
    };

    // 封装所有Value相关操作的嵌套类
    class ValueOperator {
    public:
        void Create() {
            // 替换为实际的注册表值创建逻辑
            std::cout << "Regedit.Value.Create() 被调用" << std::endl;
        }
        void Read() {
            // 替换为实际的注册表值读取逻辑
            std::cout << "Regedit.Value.Read() 被调用" << std::endl;
        }
        // 可继续扩展Value的其他方法，比如Write、Delete等
    };

    // 公开成员对象，作为对应操作的调用入口
    KeyOperator Key;
    ValueOperator Value;
};

// 全局实例化主类，如果你不需要全局使用，也可以在业务代码中按需实例化
RegeditAccessor Regedit;

// 测试调用
int main() {
    Regedit.Key.Create();
    Regedit.Value.Create();
    Regedit.Value.Read();
    return 0;
}

运行后输出如下：

Regedit.Key.Create() 被调用
Regedit.Value.Create() 被调用
Regedit.Value.Read() 被调用

共享主类状态的变种实现 #

如果Key、Value的操作需要访问主类的公共资源（比如全局注册表句柄、配置参数等），可以在嵌套类中保存主类的引用，改造示例如下：

#include <windows.h> // 引入注册表相关头文件，仅示例用

class RegeditAccessor {
private:
    HKEY m_rootHandle; // 主类保存的公共资源：根键句柄
public:
    class KeyOperator {
    private:
        RegeditAccessor& m_parent; // 保存父类实例引用
    public:
        // 构造时传入父类引用
        explicit KeyOperator(RegeditAccessor& parent) : m_parent(parent) {}
        void Create() {
            // 可直接访问父类的公共/私有成员
            RegCreateKeyExA(m_parent.m_rootHandle, "SOFTWARE\\TestPath", 0, NULL, 0, KEY_WRITE, NULL, NULL, NULL);
        }
    };

    class ValueOperator {
    private:
        RegeditAccessor& m_parent;
    public:
        explicit ValueOperator(RegeditAccessor& parent) : m_parent(parent) {}
        void Read() {
            DWORD dataLen = 256;
            char buffer[256];
            RegGetValueA(m_parent.m_rootHandle, "SOFTWARE\\TestPath", "TestValue", RRF_RT_ANY, NULL, buffer, &dataLen);
        }
        void Create() {
            // 对应值创建逻辑
        }
    };

    // 主类构造函数，初始化成员对象时传入自身引用
    RegeditAccessor() : Key(*this), Value(*this) {
        // 初始化公共资源，比如打开根键
        RegOpenKeyExA(HKEY_LOCAL_MACHINE, "SOFTWARE", 0, KEY_READ | KEY_WRITE, &m_rootHandle);
    }
    ~RegeditAccessor() {
        // 释放公共资源
        RegCloseKey(m_rootHandle);
    }

    KeyOperator Key;
    ValueOperator Value;
};

// 实例化后即可正常调用
RegeditAccessor Regedit;

简化写法（不推荐） #

如果不需要复用嵌套类的定义，也可以用匿名嵌套类直接定义成员，代码更短但可读性更低：

class RegeditAccessor {
public:
    class {
    public:
        void Create() { /* 逻辑 */ }
    } Key;
    class {
    public:
        void Create() { /* 逻辑 */ }
        void Read() { /* 逻辑 */ }
    } Value;
};

内容的提问来源于stack exchange，提问作者user10825637