C++：实现同一接口的对象/类间共享数据的权限控制方案问询

这确实是C++开发中共享数据时绕不开的痛点——你需要让实现统一接口的类共享数据集，但又不想给它们无差别修改所有数据的权限，现有的全局变量、单例、依赖注入都没法很好地解决这个封装性问题。针对你提到的状态机和大型算法子例程这两个场景，我整理了几个实用的设计方案，既能保证接口一致性，又能精准控制数据访问权限：

方案1：细粒度接口拆分（最小权限原则） #

核心思路是把原本臃肿的SharedData拆分成多个只读/读写的专用接口，让不同的子类只依赖自己真正需要的接口，从根源上限制访问范围。

步骤1：定义细分的访问接口 #

// 基础只读接口：提供所有共享数据的读取能力
class SharedDataReadOnly {
public:
    virtual double GetVar() const = 0;
    virtual bool GetFlag() const = 0;
protected:
    ~SharedDataReadOnly() = default; // 禁止直接删除接口对象
};

// 仅允许读写Var的接口：继承只读接口，增加写权限
class SharedDataVarWritable : public SharedDataReadOnly {
public:
    virtual void SetVar(double in_var) = 0;
protected:
    ~SharedDataVarWritable() = default;
};

// 仅允许读写Flag的接口：同理扩展
class SharedDataFlagWritable : public SharedDataReadOnly {
public:
    virtual void SetFlag(bool in_flag) = 0;
protected:
    ~SharedDataFlagWritable() = default;
};

步骤2：让原始SharedData实现所有接口 #

class SharedData : public SharedDataVarWritable, public SharedDataFlagWritable {
public:
    double GetVar() const override { return var; }
    bool GetFlag() const override { return flag; }
    void SetVar(double in_var) override { var = in_var; }
    void SetFlag(bool in_flag) override { flag = in_flag; }
private:
    double var;
    bool flag;
};

步骤3：给不同子类绑定对应接口 #

以状态机场景为例，调整接口和子类：

class StateIface {
public:
    virtual ~StateIface() = default;
};

// 只需要操作Var的状态类接口
class StateVarHandler : public StateIface {
public:
    virtual void Run(SharedDataVarWritable* data) = 0;
};

// 只需要操作Flag的状态类接口
class StateFlagHandler : public StateIface {
public:
    virtual void Run(SharedDataFlagWritable* data) = 0;
};

// ConcreteStateA只能读写Var，无法操作Flag
class ConcreteStateA : public StateVarHandler {
public:
    void Run(SharedDataVarWritable* data) final {
        double current = data->GetVar();
        data->SetVar(current + 1.0);
        // 尝试调用data->SetFlag(true)会直接编译报错，从源头阻止越权
    }
};

// ConcreteStateB只能读写Flag，无法操作Var
class ConcreteStateB : public StateFlagHandler {
public:
    void Run(SharedDataFlagWritable* data) final {
        bool current = data->GetFlag();
        data->SetFlag(!current);
    }
};

优点：编译期就完成权限检查，错误提前暴露，完全遵循最小权限原则；缺点：接口数量会随共享数据字段增加而增多，适合权限固定的简单场景。

方案2：代理类+动态访问策略 #

如果不想拆分太多接口，可以给SharedData套一层代理，根据不同子类的身份动态控制访问权限，适合权限可能需要动态调整的场景。

步骤1：定义访问策略基类 #

class AccessPolicy {
public:
    virtual bool CanReadVar() const = 0;
    virtual bool CanWriteVar() const = 0;
    virtual bool CanReadFlag() const = 0;
    virtual bool CanWriteFlag() const = 0;
    virtual ~AccessPolicy() = default;
};

// 给ConcreteStateA定制的策略：允许读写Var，只读Flag
class StateAPolicy : public AccessPolicy {
public:
    bool CanReadVar() const override { return true; }
    bool CanWriteVar() const override { return true; }
    bool CanReadFlag() const override { return true; }
    bool CanWriteFlag() const override { return false; }
};

// 给ConcreteStateB定制的策略：允许读写Flag，只读Var
class StateBPolicy : public AccessPolicy {
public:
    bool CanReadVar() const override { return true; }
    bool CanWriteVar() const override { return false; }
    bool CanReadFlag() const override { return true; }
    bool CanWriteFlag() const override { return true; }
};

步骤2：实现代理类 #

class SharedDataProxy {
public:
    SharedDataProxy(SharedData* real_data, std::unique_ptr<AccessPolicy> policy)
        : m_real_data(real_data), m_policy(std::move(policy)) {}

    double GetVar() const {
        if (!m_policy->CanReadVar()) {
            throw std::runtime_error("无权限读取Var");
            // 也可以用断言、日志等方式处理越权行为
        }
        return m_real_data->GetVar();
    }

    void SetVar(double in_var) {
        if (!m_policy->CanWriteVar()) {
            throw std::runtime_error("无权限修改Var");
        }
        m_real_data->SetVar(in_var);
    }

    // Flag的读写逻辑同理
    bool GetFlag() const {
        if (!m_policy->CanReadFlag()) {
            throw std::runtime_error("无权限读取Flag");
        }
        return m_real_data->GetFlag();
    }

    void SetFlag(bool in_flag) {
        if (!m_policy->CanWriteFlag()) {
            throw std::runtime_error("无权限修改Flag");
        }
        m_real_data->SetFlag(in_flag);
    }

private:
    SharedData* m_real_data;
    std::unique_ptr<AccessPolicy> m_policy;
};

步骤3：调整状态机接口 #

class StateIface {
public:
    virtual void Run(SharedDataProxy proxy) = 0;
    virtual ~StateIface() = default;
};

class ConcreteStateA : public StateIface {
public:
    void Run(SharedDataProxy proxy) final {
        proxy.SetVar(proxy.GetVar() + 1.0);
        // 尝试调用proxy.SetFlag(true)会触发运行时错误
    }
};

优点：权限策略可以动态调整，灵活性高；缺点：错误在运行时暴露，需要额外的错误处理逻辑。

方案3：CRTP+编译期权限检查（进阶） #

如果想要编译期安全的同时避免过多接口，可以用CRTP（奇异递归模板模式）给不同子类绑定权限标签，实现零运行时开销的权限控制。

步骤1：定义权限标签 #

// 权限标签：标记允许读写Var
struct VarReadWrite {};
// 权限标签：标记允许读写Flag
struct FlagReadWrite {};
// 权限标签：标记仅读Var
struct VarReadOnly {};
// 权限标签：标记仅读Flag
struct FlagReadOnly {};

步骤2：实现CRTP访问器 #

template<typename Derived, typename... Permissions>
class SharedDataAccessor {
public:
    SharedDataAccessor(SharedData* data) : m_data(data) {}

    // 只有当VarReadWrite在权限列表中时，才允许调用SetVar
    template<typename = std::enable_if_t<(std::is_same_v<Permissions, VarReadWrite> || ...)>>
    void SetVar(double in_var) {
        m_data->SetVar(in_var);
    }

    // 只要有权限标签包含读Var的权限，就允许调用GetVar
    template<typename = std::enable_if_t<(std::is_same_v<Permissions, VarReadWrite> || std::is_same_v<Permissions, VarReadOnly> || ...)>>
    double GetVar() const {
        return m_data->GetVar();
    }

    // Flag的读写逻辑同理
    template<typename = std::enable_if_t<(std::is_same_v<Permissions, FlagReadWrite> || ...)>>
    void SetFlag(bool in_flag) {
        m_data->SetFlag(in_flag);
    }

    template<typename = std::enable_if_t<(std::is_same_v<Permissions, FlagReadWrite> || std::is_same_v<Permissions, FlagReadOnly> || ...)>>
    bool GetFlag() const {
        return m_data->GetFlag();
    }

private:
    SharedData* m_data;
};

步骤3：给子类绑定权限 #

class StateIface {
public:
    virtual void Run() = 0;
    virtual ~StateIface() = default;
};

// 给ConcreteStateA绑定：读写Var、只读Flag
class ConcreteStateA : public StateIface, public SharedDataAccessor<ConcreteStateA, VarReadWrite, FlagReadOnly> {
public:
    ConcreteStateA(SharedData* data) : SharedDataAccessor(data) {}

    void Run() final {
        SetVar(GetVar() + 1.0); // 合法
        // SetFlag(true); // 编译错误，权限不允许
    }
};

// 给ConcreteStateB绑定：读写Flag、只读Var
class ConcreteStateB : public StateIface, public SharedDataAccessor<ConcreteStateB, FlagReadWrite, VarReadOnly> {
public:
    ConcreteStateB(SharedData* data) : SharedDataAccessor(data) {}

    void Run() final {
        SetFlag(!GetFlag()); // 合法
        // SetVar(2.0); // 编译错误
    }
};

优点：编译期检查，零运行时开销，代码结构紧凑；缺点：模板语法有一定学习成本，适合性能敏感、需要编译期安全的场景。

方案对比总结 #

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