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

Global declaration of data structure with parameter

本文关键字：声明 全局 数据结构 参数      更新时间：2023-10-16

我在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) {
}

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

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();
}

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

  1. 静态初始化(大约：编译时已知的常量，例如命名空间范围内的int var= 42;(

  2. 动态初始化(大约：需要运行一些代码来初始化它们，例如在命名空间范围内int var2 = foo()(

这基本上意味着您必须执行以下几件事之一：

稍后创建(或初始化(对象。

这是我向您推荐的方法。这些实际上是 2 个不同的解决方案，一个带有指针，一个带有已构造对象的后期初始化，但两者具有相同的想法，所以我将它们聚集在同一组中。我将只探索指针变体，另一个应该很容易理解。

这意味着将lru_cache声明为指针，而不是按值声明。稍后，只要加载了所需的数据，就可以动态地创建一个对象。

指针解决方案如下所示：

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)方法来初始化对象。

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

  1. 如果我们没有调用load_paramter()，调用它并将结果存储在本地静态中。
  2. 使用本地静态构造一个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()
{
}
相关文章：