Question

可以继承单例类。如是，那我们怎么做呢？

**编辑：***我的意思是说，如果我们有一个使用单一设计模式的类，那么它可以被继承吗？*

Answer 1

singleton有私有构造函数，所以继承是不可能的。除了singleton有静态方法来实例化私有实例成员，并且由于你不能覆盖静态方法，从单例继承是没有意义的。

Answer 2

这取决于您对设计模式的实现方式。最简单的形式是创建一个这样的类：

class MySingleton
{
    public:
        static MySingleton &getInstance()
        {
            static MySingleton instance;            
            return instance;
        }
    private:
        MySingleton();
        ~MySingleton();
};

在这种情况下，它不能被继承，因为派生类无法访问其构造函数。您可以使构造函数受到保护，但这将使其他派生类可以随意使用非单例，从设计角度来看可能会很混乱。但通常这种简单的形式不是实现单例的首选方式，因为你对它的生命周期没有太多控制，而且很难正确处理单例之间的依赖关系 - 更不用说可能的多线程问题了。书籍现代C ++设计（http://www.amazon.com/Modern-Design-Generic-Programming-Patterns/dp/0201704315/ref=sr_1_1?ie=UTF8&s=books&qid=1270652521）等等，有更好的实现;它们是基于模板的，模板实例化是使对象成为单例的原因（其参数是将成为单例的类）。这样可以更容易地做你想要的，因为'singleton-ness'与类本身分离。但是，我认为你需要一些策略（可能由代码强制执行），以避免从单例派生的某些类是非单例，这很难实现。

我的建议是将抽象基类作为单例的祖先，并将commom行为置于其中，而不是单例本身，并将单例始终作为“final”类（从Java借用此含义）

Answer 3

Singleton类是要继承的。没有继承，单例模式没有多大价值。

使用静态instance()成员函数定义一个主要是抽象的基类。
定义一个或多个实现基接口的派生类。
实现instance()以在运行时决定实例化和返回哪个类。

Answer 4

我有一个Singleton类，我在很多情况下继承了它。

这是Singleton：

template <class Target>
class Singleton_Shared_Ptr
{
    //---------------------------------------------------------------------
    //  Public Constructors & Destructors
    //---------------------------------------------------------------------
  public:
    //! Destructor.
    virtual         ~Singleton_Shared_Ptr();

    //---------------------------------------------------------------------
    //  Public methods
    //---------------------------------------------------------------------
  public:
    //! Returns a pointer to the instance.
    static boost::shared_ptr<Target>    ptr(void);

    //! Returns a reference to the instance.
    static Target &                     ref(void);

    //---------------------------------------------------------------------
    //  Protected methods
    //---------------------------------------------------------------------
  protected:
    //! Default constructor.
                    Singleton_Shared_Ptr();

    //---------------------------------------------------------------------
    //  Private methods
    //---------------------------------------------------------------------
  private:
     //! Copy constructor, not implemented.
     /*! The copy constructor is declared so that the compiler will not
      *  automatically generate one.
      */
                   Singleton_Shared_Ptr(const Singleton_Shared_Ptr& s);

     //! Assignment operator, declared but not defined.
     /*! The assignment operator is declared so that the compiler will not
      *  automatically generate one.
      */
    Singleton_Shared_Ptr&     operator=(const Singleton_Shared_Ptr& s);

    //---------------------------------------------------------------------
    //  Private members
    //---------------------------------------------------------------------
  private:
    static wxMutex                      m_instance_mutex;
};

template<class Target>
wxMutex                     Singleton_Shared_Ptr<Target>::m_instance_mutex;

//-------------------------------------------------------------------------
//  Singleton_Shared_Ptr Constructors & Destructors
//-------------------------------------------------------------------------
template <class Target>
inline
Singleton_Shared_Ptr<Target> ::
Singleton_Shared_Ptr()
{
}


template <class Target>
inline
Singleton_Shared_Ptr<Target> ::
~Singleton_Shared_Ptr()
{
}


//-------------------------------------------------------------------------
//  Singleton_Shared_Ptr methods in alphabetical order
//-------------------------------------------------------------------------
template <class Target>
boost::shared_ptr<Target>
Singleton_Shared_Ptr<Target> ::
ptr(void)
{
    static boost::shared_ptr<Target>    p_instance;
    if (p_instance.get() == NULL)
    {
        wxMutexLocker   lock(m_instance_mutex);
        if (!p_instance)
        {
            p_instance.reset(new Target);
        }
    }
    return p_instance;
}


template <class Target>
Target &
Singleton_Shared_Ptr<Target> ::
ref(void)
{
    return *(ptr());
}

以下是单身人士的用法：

class Manager
    : public Singleton_Shared_Ptr<Manager>
{
    //---------------------------------------------------------------------
    //  Friends
    //---------------------------------------------------------------------
    friend class Common::Singleton_Shared_Ptr<Manager>;

    //---------------------------------------------------------------------
    //  Public Constructors and Destructors
    //---------------------------------------------------------------------
  public:
    //! destructor
    virtual                 ~Manager();

    //---------------------------------------------------------------------
    //  Protected Methods
    //---------------------------------------------------------------------
  protected:
    //! Constructor
                                Manager();

    //! Copy constructor -- declared but not implemented.
                                Manager(const Manager& m);

    //! Assignment operator -- declared but not implemented.
    Manager&                    operator= (const Manager& m);
};

C ++ - Singleton类

4 个答案: