The Singleton design model is widely used and easy to implement. It is nothing more than private several constructors, the "operator =" operator, and provides a static creation and destruction method. But write these identicalCodeIt is intolerable for the current seat. Therefore, the whole Singleton mode is encapsulated using macros. Whether it is the definition of a class or the use of a class is extremely simple, please refer to the Code:
/* **************************************** *************************************
Module: Singleton. h
Notices: Copyright (c) 2006 Bruce Liang
Purpose: Used to simplify the definition of Singleton mode.
Desc:
**************************************** ************************************* */
# Pragma Once
# Define Singleton_this (classname) classname: getthis ()
# Define Singleton_instance (classname) classname: getinstance ()
# Define Singleton_object (objname) singleton_instance (C # objname)
# Define Define_singleton (classname )\
Classname * classname: m_pthis = NULL;
# Define Define_p_this (classname )\
Define_singleton (classname)
# Define Declare_singleton_interface (classname )\
Public :\
Static Classname * getthis (){ Return M_pthis ;}\
Static Classname & getinstance (){ Return * M_pthis ;}\
Protected :\
Static Classname * m_pthis;
# Define Declare_singleton_create_instance (classname )\
Public :\
Static Bool createinstance ()\
{\
If (! M_pthis )\
M_pthis = New Classname ;\
\
Return M_pthis! = NULL ;\
}\
\
Static Bool deleteinstance ()\
{\
If (M_pthis )\
{\
Delete m_pthis ;\
M_pthis = NULL ;\
}\
\
Return M_pthis = NULL ;\
}
# Define Declare_private_default_constructor (classname )\
Private :\
Classname (){}
# Define Declare_private_copy_constructor (classname )\
Private :\
Classname ( Const Classname &);\
Classname & Operator = ( Const Classname &);
# Define Declare_no_copy_class (classname )\
Declare_private_copy_constructor (classname)
# Define Declare_singleton_implement_no_create_instance (classname )\
Declare_singleton_interface (classname )\
Declare_private_default_constructor (classname )\
Declare_private_copy_constructor (classname)
# Define Declare_singleton_implement_no_default_constructor (classname )\
Declare_singleton_create_instance (classname )\
Declare_private_copy_constructor (classname)
# Define Declare_singleton_implement (classname )\
Declare_singleton_implement_no_default_constructor (classname )\
Declare_private_default_constructor (classname)
# Define Declare_singleton_no_default_constructor (classname )\
Declare_singleton_interface (classname )\
Declare_singleton_implement_no_default_constructor (classname)
# Define Declare_singleton (classname )\
Declare_singleton_no_default_constructor (classname )\
Declare_private_default_constructor (classname)
Template < Class T>
Class Csingleobject
{
Public :
Csingleobject () {T: createinstance ();}
~ Csingleobject () {T: deleteinstance ();}
T * getpointer (){ Return T: getthis ();}
T & GetObject (){ Return T: getinstance ();}
Bool isvalid (){ Return Getpointer ()! = NULL ;}
};
# DefineDeclare_single_object (classname) csingleobject <classname >## classname ##_ single_object _;
- Singleton Class header file (Myclass. h)
# Pragma Once
# Include " ../Common/src/singleton. h "
// For ease of use, define 'myclass' instead of 'cmyclass: getinstance ()'
# Define Myclass singleton_instance (cmyclass)
Class Cmyclass
{
Private :
Int X;
Int Y;
Public :
Int Mix ();
Private :
// Custom Constructor (optional)
Cmyclass (): X ( 123 ), Y ( 456 ){}
/* ***** Declare Singleton **** */
// If no custom constructor exists, Singleton declares:
// Declare_singleton (cmyclass)
// Otherwise, the statement is:
Declare_singleton_no_default_constructor (cmyclass)
};
- Singleton class implementation file (Myclass. cpp)
# Include"Stdafx. h"
# Include"Myclass. h"
//Declaration: cmyclass * cmyclass: m_pthis
Define_singleton (cmyclass)
IntCmyclass: mix ()
{
ReturnX * Y;
}
# Include"Stdafx. h"
# Include"Myclass. h"
//Use cmyclass: createinstance () to create a unique instance
Declare_single_object (cmyclass)
Int_ Tmain (IntArgc, _ tchar * argv [])
{
//Access a unique instance
IntResult = myclass. Mix ();
STD: cout <result <Endl;
Return 0;
}
Codeproject