我在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++分两个阶段初始化具有静态生存期的对象：
-
静态初始化(大约：编译时已知的常量，例如命名空间范围内的
int var= 42;( -
动态初始化(大约：需要运行一些代码来初始化它们，例如在命名空间范围内
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)方法来初始化对象。
创建一个类似工厂的函数，它将初始化创建对象
- 如果我们没有调用
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()
{
}