Use macro to implement the C ++ Singleton Mode

Source: Internet
Author: User

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;
}

 

    • Usage
 
# 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

Contact Us

The content source of this page is from Internet, which doesn't represent Alibaba Cloud's opinion; products and services mentioned on that page don't have any relationship with Alibaba Cloud. If the content of the page makes you feel confusing, please write us an email, we will handle the problem within 5 days after receiving your email.

If you find any instances of plagiarism from the community, please send an email to: info-contact@alibabacloud.com and provide relevant evidence. A staff member will contact you within 5 working days.

A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

  • Sales Support

    1 on 1 presale consultation

  • After-Sales Support

    24/7 Technical Support 6 Free Tickets per Quarter Faster Response

  • Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.