Question

目前我正面临与Singleton类相关的问题。这是场景：我有3个Singleton类，即

class BaseConfiguration : public TSingleton<BaseConfiguration>{
};

class ComponentConfiguration : public BaseConfiguration, public TSingleton<ComponentConfiguration>{
};

class ComposedConfiguration : public BaseConfiguration, public TSingleton<ComposedConfiguration >{
};

ComponentConfiguration和ComposedConfiguration应该初始化BaseConfiguration，因为它们都使用BaseConfiguration。 BaseConfiguration也可以作为自己的初始化。

ComposedConfiguration * InitializeComposed()
{
  TSingleton<BaseConfiguration>::CreateInstance();
  return TSingleton<ComposedConfiguration >::CreateInstance();
}

ComponentConfiguration* InitializeComponent()
{
  TSingleton<BaseConfiguration>::CreateInstance();
  return TSingleton<ComponentConfiguration>::CreateInstance();
}

BaseConfiguration * InitializeBaseConfig()
{
 return TSingleton<BaseConfiguration>::CreateInstance();
}

组合和组件配置是独立的。

问题是如何销毁BaseConfiguration的实例。 Composed和组件配置都可能使用Base Configuration实例，例如：在销毁Composed时，如果我在析构函数中销毁Base Configuration，组件配置将崩溃。此外，还可以使用InitializeBaseConfig函数初始化BaseConfiguration。删除BaseConfiguration实例或调用TSingleton :: DestroyInstance（）的最佳方法是什么，这样任何模块都不会崩溃，也不会泄漏任何内存。

由于

Answer 1

我的第一个建议就是不要继承BaseConfiguration。这些是单例，因此是伪装的静态变量和方法，因此继承几乎没有什么好处。如果你想在其他单例中提供BaseConfiguration中的相同方法，可以编写简单的包装器，例如：

some_type SomeMethod() { 
    return TSingleton<BaseConfiguration>::Instance()->SomeMethod();
}

除非有几十个，否则不是问题。

我的另一个建议是完全放弃Singleton模式。定期上课。然后他们的物体可以有规律的寿命。如果你真的不需要一个以上，那很好，只是不要分配多个。在这种情况下，如果您愿意，可以从某些BaseConfig继承，并且不会有任何特殊之处。如果要避免在两个配置对象中有两个std::shared_ptr<>子对象，也可以避免继承并使两个配置对象都保持BaseConfig到BaseConfig对象。

C ++中的单例问题

1 个答案: