如何为单个对象最优实现不同权限的专属访问接口？

嘿，这个需求本质上就是给同一个核心对象创建权限隔离的视图，你的现有多继承+工厂思路方向是对的，但确实可以用轻量包装器来优化，完美避开智能指针的开销和动态分配的麻烦。

核心思路：用包装器做"接口代理" #

我们不需要让核心对象（比如你的Foo/示例里的汽车）直接继承多个接口，而是把接口隔离的逻辑放到独立的包装器里——包装器只暴露对应用户的接口，内部持有核心对象的引用，完全避免多继承的潜在问题，也不需要智能指针的引用计数开销。

方案1：支持多态的轻量包装器（适合需要接口抽象的场景） #

如果你的业务需要用基类指针传递用户接口（比如函数参数接受DriverInterface*），可以保留虚接口，但用包装器代理：

// 定义用户专属接口
class DriverInterface {
public:
    virtual void steer() = 0;
    virtual void accelerate() = 0;
    virtual void brake() = 0;
    virtual ~DriverInterface() = default;
};

class PassengerInterface {
public:
    virtual void adjustRadio() = 0;
    virtual ~PassengerInterface() = default;
};

// 核心对象：汽车（不需要继承任何接口，保持纯净）
class Car {
public:
    void steer() { /* 实际操控逻辑 */ }
    void accelerate() { /* 实际加速逻辑 */ }
    void brake() { /* 实际刹车逻辑 */ }
    void adjustRadio() { /* 实际收音机控制逻辑 */ }
};

// 驾驶员包装器：仅暴露驾驶员权限的接口
class DriverWrapper : public DriverInterface {
public:
    explicit DriverWrapper(Car& car) : car_(car) {}
    
    void steer() override { car_.steer(); }
    void accelerate() override { car_.accelerate(); }
    void brake() override { car_.brake(); }

private:
    Car& car_; // 仅持有引用，无额外内存开销
};

// 乘客包装器：仅暴露乘客权限的接口
class PassengerWrapper : public PassengerInterface {
public:
    explicit PassengerWrapper(Car& car) : car_(car) {}
    
    void adjustRadio() override { car_.adjustRadio(); }

private:
    Car& car_;
};

用法示例（完全栈分配，无动态内存）：

int main() {
    // 核心对象栈分配，完全避开std::make_shared
    Car my_car;
    
    // 给不同用户创建专属包装器
    DriverWrapper driver(my_car);
    PassengerWrapper passenger(my_car);
    
    // 用户1只能调用驾驶相关方法
    driver.steer();
    // driver.adjustRadio(); // 编译错误！看不到这个方法
    
    // 用户2只能调用收音机方法
    passenger.adjustRadio();
    // passenger.steer(); // 编译错误！看不到这个方法
    
    return 0;
}

方案2：编译时绑定的视图类（性能极致优化） #

如果你的业务不需要多态传递（比如不需要用基类指针/引用接收接口），可以去掉虚函数，用纯静态的视图类，连虚表的开销都能省：

// 核心对象Car和之前一样，保持不变

// 驾驶员视图：编译时绑定，无虚函数
class DriverView {
public:
    explicit DriverView(Car& car) : car_(car) {}
    
    void steer() { car_.steer(); }
    void accelerate() { car_.accelerate(); }
    void brake() { car_.brake(); }

private:
    Car& car_;
};

// 乘客视图：编译时绑定，无虚函数
class PassengerView {
public:
    explicit PassengerView(Car& car) : car_(car) {}
    
    void adjustRadio() { car_.adjustRadio(); }

private:
    Car& car_;
};

这个版本的优势是零运行时开销——所有调用都是编译时静态绑定，没有虚函数跳转，也没有智能指针的引用计数操作，完全符合你对性能的要求。

对比原有方案的优势 #

• 无不必要的开销：既不用std::shared_ptr的引用计数，也不用动态分配核心对象（可以栈分配或自定义内存管理）
• 接口隔离更彻底：包装器只能看到对应权限的方法，编译时就会阻止越权调用，比多继承更安全
• 核心对象更纯净：核心对象不需要继承一堆接口，专注于实现业务逻辑，耦合度更低
• 生命周期可控：核心对象的生命周期由你完全掌控，包装器只是持有引用，不会引入智能指针的生命周期管理复杂度

注意事项 #

• 包装器持有核心对象的引用，必须保证核心对象的生命周期长于所有包装器，避免悬空引用
• 如果确实需要动态分配核心对象，可以用自定义内存池（比如预先分配的内存块）替代std::make_shared，进一步降低开销

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