C++ design pattern Singleton

1. Function: Ensure that a class has only one instance. 3. Advantages and Disadvantages The Singleton mode appears as a replacement for "global variables". Therefore, it has the characteristics of a global variable: it is globally visible and runs throughout the entire life cycle of the application. It also has properties that global variables do not have: there can only be one object instance of the same type. 4. Implement the Singleton definition in the textbook as follows:
class Singleton
{
public:
static Singleton* Instance() ;
PRotected:
Singleton() {}
private:
static Singleton *_instance ;
Singleton(const Singleton& ) ;
Singleton& Operator=(const Singleton&) ;
} ; Singleton* Singleton::_instance = NULL ; Singleton* Singleton::Instance()
{
(_instance == NULL) ? _instance = new Singleton() : 0 ; //lazy initialization
return _instance ;
} ​ (1) Because it returns a pointer, in order to prevent users from calling the delete function, static Singleton *_instance; can be changed to define static Singleton _instance in Instance(). This is obviously safer, and it also has the characteristics of lazy initialization (that is, it is created only when accessed for the first time).

　　(2) Suppose you need to derive a subclass from Singleton, and the subclass also needs to have the same properties, which can only create one instance. I think this is difficult to do. The fundamental reason is that the Instance() function is not a virtual function and does not have polymorphic properties. A common method is to move the Instance() function into a subclass. At this time, you can only use static Singleton *_instance, but not static Singleton _instance. Unless you also move _instance to the subclass, no matter what you do, Not elegant. Another way is to use templates. The specific method to use can only be weighed according to the actual situation.

　5. Sample code (1) Without subclass namespace DesignPattern_Singleton
{ class Singleton
{
public:
static Singleton* Instance() { static Singleton _instance; return &_instance; }
protected:
Singleton() {}
private:
Singleton(const Singleton&) ;
Singleton& operator=(const Singleton&) ;
} ;
} Client code:
{
using namespace DesignPattern_Singleton ;
Singleton *p = Singleton::Instance() ;
.. ....
} 　(2) When there are subclasses
Method 1:
namespace DesignPattern_Singleton
{
// class Singleton
class Singleton
{
protected:
Singleton() {}
static Singleton *_instance;
private :
Singleton(const Singleton&) ;
Singleton& operator=(const Singleton&) ;
} ;
Singleton* Singleton::_instance = NULL ; // class ConcreteSingleton
class ConcreteSingleton : public Singleton
{
public:
static Singleton* Instance () ;
protected:
ConcreteSingleton() {}
} ; Singleton* ConcreteSingleton::Instance()
{
(_instance == NULL) ? _instance = new ConcreteSingleton() : 0 ;
return _instance ;
}
} Client code:
{
using namespace DesignPattern_Singleton;
Singleton *p = ConcreteSingleton::Instance();
} Method 2:
namespace DesignPattern_Singleton
{
// class Singleton
class Singleton
{
protected:
Singleton() {}
private:
Singleton(const Singleton&) ;
Singleton& operator=(const Singleton&) ;
} ; // class ConcreteSingleton
class ConcreteSingleton : public Singleton
{
public:
static Singleton* Instance() { static ConcreteSingleton _instance ; return &_instance ; }
protected:
ConcreteSingleton() {}
} ;
} Client code:
{
using namespace DesignPattern_Singleton ;
Singleton *p = ConcreteSingleton::Instance() ;

} Method three:
namespace DesignPattern_Singleton
{
template < class T >
class Singleton
{
public:
static T* Instance() { static T _instance ; return &_instance ; }
protected:
Singleton() {}
private:
Singleton( const Singleton &) ;
Singleton& operator=(const Singleton&) ;
} ; class ConcreteSingleton : public Singleton< ConcreteSingleton > {} ;
} Client code
{
using namespace DesignPattern_Singleton ; ConcreteSingleton *p = ConcreteSingleton::Instance( ) ;
}

The above is the content of Singleton in C++ design pattern. For more related articles, please pay attention to the PHP Chinese website (www.php.cn)!