Question

我在设计软件时遇到了问题。我有一个非常大的对象（BO），让我们说一个动态数组的映射，我需要访问各种类。每次类使用BO时，它都会向其添加新数据，或者使用BO中的一些数据来进行计算。

作为一个新手，我迷失在如何用C ++设计这样一个对象，以便我的代码设计和架构是好的。研究Singleton时，制作一个全局变量是不够有效的，但发现规则是你只能访问该对象，而不是改变它。

任何人都能指出我正确的方向吗？我应该遵循哪种设计模式才是最有效和可扩展的？

由于

根据这里的答案，以下是正确的设计 - 它的psudo！

Class BigObject {

private static BigObject instance = null;
private map;
private BigObject() { }

public static BigObject getInstance() {
    if (instance == null) {
        instance = new BigObject();
    }
    return instance;
}

public getArray(string key) {
    return map[key];
}

public setBigObject(string key, Array value) {
    map.insert(key, value);
}

Answer 1

“但发现规则是您只能访问该对象，而不是更改它。”

你可能误解了那里的东西？单例的唯一目的是保证具有类的单个实例。您仍然可以在其类成员函数允许的情况下更改其状态。

关于您在更新后的问题中发布的单例实现，您应该将其改进为线程安全（在Scott Meyer's Singleton之后）：

class BigObject {
    std::map<std::string,Array> map;
    BigObject() { }

public:
    static BigObject& getInstance() {
        static BigObject instance;
        return instance;
    }

    const Array& getArray(std::string key) const {
        return map[key];
    }

    void setBigObject(string key, Array value) {
         map.insert(key, value);
    }
};

但是当 Singleton 将您的客户端代码紧密地耦合到单例类时，您可能应该为 BigObject 声明一个接口，在类中引用需要访问，并从构造中传递一个实例：

struct IBigObject {
     virtual void doCostlyCalculations() = 0;
     virtual void updateData(std::vector<int> record) = 0;
     virtual ~IBigObject() {}
};

class BigObject : public IBigObject {
     virtual void doCostlyCalculations() {
          // Implementation ...
     }
     virtual void updateData(std::vector<int> record) {
          // Implementation ...
     }
};

class ClientA {
     IBigObject& bo_;
public:
     ClientA(IBigObject& bo) : bo_(bo) {}
}

class ClientB {
     IBigObject& bo_;
public:
     ClientA(IBigObject& bo) : bo_(bo) {}
}

int main() {
    BigObject bo;
    ClientA ca(bo);
    ClientB cb(bo);

    // ...
};

创建系统范围的资源C ++

1 个答案: