基于组合模式重构House类：组件API设计与访问方案咨询

这是个典型的“上帝类”重构场景，你的组合模式思路完全找对方向了！咱们一步步解决你的两个困惑：

一、公共API的放置：组件专属API归位到各自类中 #

绝对应该把窗户、门、墙壁的属性和方法拆分到对应的Window、Door、Wall类里——这正是单一职责原则的核心：每个类只负责自己领域内的逻辑，House只需要扮演组合者的角色，负责协调各个组件，而不是包揽所有细节。

举个具体的代码实现例子：

// 先定义各个组件类，各自管理自己的属性和方法
class Wall {
public:
    void setColor(int color) { m_color = color; }
    int getColor() const { return m_color; }
    void setHeight(int height) { m_height = height; }
    int getHeight() const { return m_height; }
private:
    int m_color;
    int m_height;
};

class Door {
public:
    void setColor(int color) { m_color = color; }
    int getColor() const { return m_color; }
    void setWidth(int width) { m_width = width; }
    int getWidth() const { return m_width; }
private:
    int m_color;
    int m_width;
};

class Window {
public:
    void setColor(int color) { m_color = color; }
    int getColor() const { return m_color; }
    void open() { m_isOpen = true; }
    void close() { m_isOpen = false; }
    bool isOpen() const { return m_isOpen; }
private:
    int m_color;
    bool m_isOpen = false;
};

然后House类只需要组合这些组件，并根据需求提供访问接口：

class House {
public:
    // 提供组件的访问方法，区分可变和只读场景
    Door& getDoor() { return m_door; }
    const Door& getDoor() const { return m_door; }
    
    Window& getWindow() { return m_window; }
    const Window& getWindow() const { return m_window; }
    
    Wall& getWall() { return m_wall; }
    const Wall& getWall() const { return m_wall; }

    // 可以封装一些House级别的整体操作，比如统一装修
    void renovate(int newWallColor, int newDoorColor) {
        m_wall.setColor(newWallColor);
        m_door.setColor(newDoorColor);
        m_window.close(); // 装修时先关窗户
    }

private:
    Wall m_wall;
    Door m_door;
    Window m_window;
    // 其他组件比如Roof、Floor等
};

二、已有函数访问组件：house.getDoor().getColor()完全可行 #

你提到的house.getDoor().getDoorColor()（对应上面例子里的house.getDoor().getColor()）是组合模式下的标准访问方式，完全没问题，而且能很好地兼容现有代码——因为所有接受House参数的函数，只需要把原来直接调用house.setDoorColor()的逻辑，改成通过组件访问器调用即可。

比如原有函数：

// 旧代码
void foo(const House& house, int param1, double param2) {
    // 原来直接访问House的属性或方法
    // int color = house.doorColor;
}

改成组合模式后的代码：

// 新代码
void foo(const House& house, int param1, double param2) {
    // 通过const引用访问组件的只读方法
    int doorColor = house.getDoor().getColor();
    bool windowOpen = house.getWindow().isOpen();
    // ... 其他逻辑
}

额外的优化建议 #

• 控制组件暴露程度：如果不想让外部直接修改组件，可以只提供const版本的getter，把修改逻辑封装在House的方法里。比如如果业务上不允许外部直接开门，就只给House加一个openDoor()方法，内部调用m_door.open()，这样House保留对组件的控制权。
• 避免过度暴露细节：如果外部不需要知道Wall的所有属性，就不要暴露整个Wall对象，而是在House里封装setWallColor(int)这类方法，降低外部代码对组件的耦合。
• 保持接口一致性：统一组件访问器的命名（比如getDoor()、getWindow()），让调用方的代码更直观易读。

这种重构方式不仅能让代码结构更清晰，还能最小化对现有代码的改动——因为所有原来接受House参数的函数，只需要调整内部访问逻辑，不需要修改函数签名，迁移成本很低。

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