Question

假设我有以下单例基类：

template <class Derived>
class Singleton
{
  public:

    inline static Derived* get();                       

  protected:

    Singleton();                                  
    ~Singleton();                                     
    static std::unique_ptr<Derived> _uptr;                

  private:

    Singleton(const Singleton&);                          
    Singleton & operator = (const Singleton&);             
};

// Initialize the singleton object.
template <class Derived>
std::unique_ptr<Derived> Singleton<Derived>::_uptr = nullptr;

// Constructor
template <class Derived>
Singleton<Derived>::Singleton() {
}

// Constructor
template <class Derived>
Singleton<Derived>::~Singleton() {
}

// Function: get
template <class Derived>
inline Derived* Singleton<Derived>::get() {
  if(_uptr != nullptr) return _uptr.get();
  std::unique_ptr<Derived> tmp(new Derived());
  _uptr = std::move(tmp);
  return _uptr.get();
}

我有以下派生类：

class Foo : public Singleton <Foo> {
  public:
    int value;     
}

int main() {
  Foo A;
  Foo B;
  A.value = 1;
  B.value = 2;
  A.get()->value = 3;
  cout << A.value << endl;  // we get 1
  cout << B.value << endl;  // we get 2
  cout << A.get()->value() << " " << B.get()->value() << endl;  // we get 3
}

我想知道为什么这三种方法在value上给出完全不同的输出。不应该A和B返回相同的值，因为它们继承了相同的单例基数吗？更具体地说，我想实现一个具有全局范围的类，并且只启动一次。

Answer 1

您仍然需要明确删除派生的Singleton类中的（自动创建的）默认构造函数和赋值运算符，以禁止实例化多个实例：

class Foo : public Singleton <Foo> {
public:
    int value;
    delete Foo();
    delete Foo(const Foo&);
    delete Foo& operator(const Foo&);
}

Answer 2

我认为你误解了单身人士模式。

它被称为单身，因为只允许一个实例。这是通过将构造函数设置为私有来完成的，这样您就只能通过get-function创建实例。

因此Foo A和Foo B将是非法的。

您得到错误的值，因为您创建了3个实例 - 这不是单例。

请参阅https://en.wikipedia.org/wiki/Singleton_pattern

Answer 3

您的班级Foo有一个成员变量int value，还有一个静态成员变量std::unique_ptr<Foo> _uptr。

A.value = 1;        // now A.value == 1 and _uptr == nullptr
B.value = 2;        // now B.value == 2 and _uptr == nullptr
A.get()->value = 3; // now _uptr points to a Foo whose value is 3

有三个Foos和三个值。

单例类和多重继承

3 个答案: