Question

我在main（）中使用了LRU数据结构，如下所示。

int main()
{
    load_parameter();
    cache::lru_cache<int, float> states_action0(STATES_NO_LRU);
    cache::lru_cache<int, float> states_action1(STATES_NO_LRU);   
    cache::lru_cache<int, float> states_action2(STATES_NO_LRU);
    .........

}

请注意，STATES_NO_LRU是整数类型变量，在main（）的开头加载。

但是，我想将LRU数据结构声明移到main（）外部以声明为全局类型。

在全局声明区域，无法加载STATES_NO_LRU。在这种情况下，如何处理STATES_NO_LRU变量？总而言之，我想将lru_cache用作全局数据结构。

lru_cache的源代码（标头部分）如下

namespace cache {

template<typename key_t, typename value_t> class lru_cache { public:
        typedef typename std::pair<key_t, value_t> key_value_pair_t;
        typedef typename std::list<key_value_pair_t>::iterator list_iterator_t;

        lru_cache(size_t max_size) :
                _max_size(max_size) {
        }

Answer 1

听起来您正在寻找单例设计模式。这是一种从应用程序中的任何位置获取类的唯一实例的方法。

class Singleton {

private: 
    // Let's prevent any other instances of this object 
    // by making the constructor private
    Singleton() 
      : states_action0(STATES_NO_LRU) // Here we initialize states_action0 to STATES_NO_LRU
    {
    } 

    // This member will be accessible everywhere and only has one instance
    cache::lru_cache<int, float> states_action0; 
    // You could also put states_action1 here too.
public: 

    static Singleton& GetInstance() {
        static Singleton theSingleton;
        return theSingleton;
    }

    // For read-only access make this const
    lru_cache& GetCache() { 
        return states_action0; 
    }
};

然后您将在应用程序中的任何地方使用它：

int main() {

    cache::lru_cache& states_action0 = Singleton::GetInstance().GetCache();
}

Answer 2

当前，当构造缓存对象时，您将传递相关参数。这意味着您在创建对象时需要知道其构造函数的参数。 C ++分两个阶段初始化具有静态生存期的对象：

静态初始化（大约：编译时已知的常量，例如，命名空间范围内的int var= 42;）
动态初始化（大约：需要运行一些代码来初始化它们，例如，在命名空间范围内int var2 = foo()）

这基本上意味着您必须执行以下其中一项操作：

稍后创建（或初始化）对象。

这是我推荐给您的方法。实际上，这是两种不同的解决方案，一种具有指针，一种具有已构造对象的后期初始化，但是两者共享相同的想法，因此我将它们捆绑在同一组中。我将仅探讨指针变量，其他变量应该易于理解。

这意味着将lru_cache声明为指针，而不是按值声明。以后，无论何时加载所需的数据，您都将动态创建一个对象。

Pointer解决方案如下所示：

size_t load_parameter() {
    //do magic;
    return 42;
}

std::unique_ptr<lru_cache<int, float>> states_action0 = nullptr;

int main()
{
    size_t STATES_NO_LRU = load_parameter();
    states_action0 = std::make_unique<lru_cache<int, float>>(STATES_NO_LRU);
}

较晚的初始化解决方案将默认构造lru_cache对象，并实现lru_cache::initialize(size_t maxSize)方法来初始化对象。

创建类似工厂的函数，该函数将初始化创建对象

如果我们尚未调用load_paramter()，请调用它并将结果存储在本地静态变量中。
使用局部静态变量构造一个lru_cache对象并返回它。

我强烈建议反对这样的解决方案。加载发生的时间是由实现定义的，并且很可能在调用main之前发生。看起来像这样：

size_t load_parameter() {
    //do magic;
    return 42;
}

lru_cache<int, float> cacheMaker()
{
    static size_t STATES_NO_LRU = -1;
    if (STATES_NO_LRU == -1)
    {
        STATES_NO_LRU = load_parameter();
    }
    return lru_cache<int, float>(STATES_NO_LRU);

}
lru_cache<int, float> states_action0 = cacheMaker();

int main()
{
}

带有参数的数据结构的全局声明

2 个答案:

稍后创建（或初始化）对象。

创建类似工厂的函数，该函数将初始化创建对象