单例类的构造函数是私有的

单例模式的核心是构造方法的私有化（即在入口处限制了对象的实例化），之后在类的内部实例化对象，并通过静态方法返回实例化对象的引用。

实现单例模式的思路

需要注意的地方：

几种单例模式实现

class Singleton
public:
    static Singleton* GetInstance()
        return &m_instance;
private:
    Singleton(){};
    Singleton(Singleton const&); 
    Singleton& operator=(Singleton const&); 
    static Singleton m_instance;
Singleton Singleton::m_instance;  // 在程序入口之前就完成单例对象的初始化
class Singleton
public :
     static Singleton & getInstance()
         return m_data;
private :
     static Singleton m_data;  //static data member 在类中声明，在类外定义
    Singleton(){}
     ~Singleton(){}
Singleton Singleton : :m_data;
懒汉式1：
 
class CSingleton  
public:  
static CSingleton* GetInstance()  
     if ( m_pInstance == NULL )    
         m_pInstance = new CSingleton();  
     return m_pInstance;  
private:  
    CSingleton(){};  
    static CSingleton * m_pInstance;  
如上懒汉式存在两个问题：
 
 
①线程不安全：我们注意到在 static Singleton* getInstance() 方法中，是通过 if 语句判断 静态实例变量是否被初始化来觉得是否进行初始化，那么在多线程中就有可能出现多次初始化的问题。比方说，有两个多线程同时进入到这个方法中，同时执行 if 语句的判断，那么就会出现两次两次初始化静态实例变量的情况
 
 
② 析构函数没有被执行： 程序退出时, 析构函数没被执行. 这在某些设计不可靠的系统上会导致资源泄漏, 比如文件句柄, socket 连接, 内存等等. 幸好 Linux / Windows 2000/XP 等常用系统都能在程序退出时自动释放占用的系统资源. 不过这仍然可能是个隐患
 
那么解决析构函数没有被执行的问题，就是加一个人为的自动回收，如下。
 
懒汉式2，标准双检索+自动回收实现：
 
class Singleton
public:
    static Singleton* GetInstance()
        if (m_pInstance == NULL )
            Lock(); // 加锁
            if (m_pInstance == NULL )
                m_pInstance = new Singleton ();
            UnLock(); // 解锁
        return m_pInstance;
    // 实现一个内嵌垃圾回收类    
    class CGarbo 
    public:
        ~CGarbo()
            if(Singleton::m_pInstance) 
                delete Singleton::m_pInstance;
    static CGarbo Garbo; // 定义一个静态成员变量，程序结束时，系统会自动调用它的析构函数从而释放单例对象
private:
    Singleton(){};
    Singleton(Singleton const&); 
    Singleton& operator=(Singleton const&); 
    static Singleton* m_pInstance;
Singleton* Singleton::m_pInstance = NULL;
Singleton::CGarbo Garbo;
再来说一说缺陷①的多线程下多次初始化破坏单例原则的线程不安全问题。
 
采用局部静态变量：
 （这里仍然要注意的是局部变量初始化的线程安全性问题，在C++0X以后，要求编译器保证静态变量初始化的线程安全性，可以不加锁。但C++ 0X以前，仍需要加锁。）
 
class Singleton
public:
    static Singleton* GetInstance()
        Lock(); // not needed after C++0x 
        static Singleton instance;  
        UnLock(); // not needed after C++0x 
        return &instance;
private:
    Singleton() {};
    Singleton(const Singleton &);
    Singleton & operator = (const Singleton &);
在懒汉模式里，如果大量并发线程获取单例对象，在进行频繁加锁解锁操作时，必然导致效率低下。
 
 
①如果这个单例对象构造十分耗时或者占用很多资源，比如加载插件，
 初始化网络连接，读取文件等等，而有可能该对象程序运行时不会用到，那么也要在程序一开始就进行初始化，也是一种资源浪费吧。所以这种情况懒汉模式（延迟加载）更好；
 
 
②如果这个单例对象在多线程高并发环境下频繁使用，性能要求较高，那么显然使用饿汉模式来避免资源竞争，提高响应速度更好
 
了解其本质就好。
 
以C++11为例
 
C++11提供的call_once和once_flag解决了单例类线程安全问题。目前在使用这个：
 
CData.h
 
class CData
public:
	CData();   //构造函数
	~CData() = default;
	CData(const CData &) = delete;
	CData &operator=(const CData &) = delete;
	static std::once_flag m_stFlag;
public:
	static CData* GetInstance(void);
	void Func();  //其他自定义方法
private:
	static CData *m_pCData;
CData.cpp
 
//初始化静态局部变量
CData *CData::m_pCData = NULL;
std::once_flag CData::m_stFlag;
CData::CData(){}
CData * CData::GetInstance(void)
	std::call_once(m_stFlag, [&]() {
		m_pCData = new CData();
	});
	return m_pCData;
void CData::Func()
	...
main.cpp
 
//调用方法
CData::GetInstance()->Func();
参考文章：
 c++单例模式的几种实现研究
 c++的三种单例模式----深度解析
 探究 C++ Singleton（单例模式）
 java版：单例模式的优缺点和使用场景
                    单例类的构造函数是私有的单例模式（单例类）：   即该类只有一个实例化对象，不管外部声明调用多少次，其本质也都是访问同一块内存。比如生活中的实例：只有一个的windows任务管理器；只有一个的windows回收站。。。单例模式的核心是构造方法的私有化（即在入口处限制了对象的实例化），之后在类的内部实例化对象，并通过静态方法返回实例化对象的引用。几种单例模式实现待定…了解其本质就好。以C++11为例C++11提供的call_once和once_flag解决了单例类线程安全问题。CData
在使用构造函数和析构函数时，需要特别注意对它们的调用时间和调用顺序。在一般情况下，调用析构函数的次序正好与调用构造函数的次序相反：最先被调用的构造函数，其对应的(同一对象中的)析构函数最后被调用，而最后被调用的构造函数，其对应的析构函数最先被调用。
简单来说，其构造函数的顺序就一句话：
基类构造函数 -> 成员的构造函数 -> 构造函数体内语句
看下面一个代码示例：
#include <iostream>
using namespace std;
class A {
 public:
  A() { cout << A() << endl; }
  ~A() { cout << 
				
本文实例讲述了PHP构造函数与析构函数用法。分享给大家供大家参考，具体如下：
在实例化一个新对象时，构造方法和析构方法都会被自动调用，若有继承则会使用父类的对应方法。
析构方法在三种情况下会被调用：
① 使用unset()销毁一个对象，若存在对象传值则不会被调用；
② 改变变量指向对象的值；
③ php程序代码运行结束后。
class base{
  public $name;
  function __construct($name){
    $this->name = $name;
    echo 'obj '.$this->name.' have built'.'</b
				
构造函数、析构函数
构造函数：
1.若没提供任何构造函数，则系统会自动提供一个默认的构造函数，初始化所有成员为默认值（引用类型为空引用null，值类型为0，bool类型为false）；
2.若提供了带参数的构造函数，则系统不提供默认的构造函数；
3.构造函数可重载：可提供多个不同版本的构造函数，依据参数的个数、类型来区分；
4.私有构造函数：则无法通过该构造函数实例化该对象，可通过调用静态函数来实例化；当仅用作某些静态成员或属性的容器时，可定义私有构造函数来防止被实例化；
一般的构造函数都是实例构造函数，只要创建实例，就执行构造函数；
静态构造函数：
1.只能定义一个，最多运行一次，仅在第一次
				
最近写完项目，正是一波总结的时候。项目中用到了大量的单例模式，然而本以为写的轻车熟路的代码，结果却问题重重，单例模式如何析构？单例模式中如何保证线程安全？如何加锁？锁要封装成单例类嘛？这个单例类构造出1个对象会不会有问题？阻塞住会不会后面上锁的功能无法正常使用？还是锁不用单例模式封装？构造锁的对象时加static？？......
不测试不知道，一测试一堆问题需要解决，好，从头开始看。
----...
				
什么是单例模式
通过对构造函数__contruct和析构函数__destruct的私有化，从而防止从类的外部通过new创建对象，然后在类的内部来进行实例化，并用静态变量存储到内存中，之后通过判断类是否已经被实例化，如果已经被实例化，则无需再创建对象。
主要用于项目中经常会用到的类，比如数据库类的实例化、Redis类的实例化等
1.不需要反复的创建对象实例，可以节省内存消耗
2.可以提升系统的性能
3.提供了唯一实例的受控访问，方便后期维护
				
singleton.md  单例模式 单件模式
     保证一个类中仅有一个实例,并且提供一个访问他的全局访问点
a. 懒汉式：使用的时候才创建，多线程访问的时候线程不安全(双检锁)
b. 饿汉式：类文件加载的时候已经创建好了对象，如果对象一直没有使用，则类对象浪费空间
    1. 构造函数私有化， 
    2. 私有的静态指向类的实例（类外声明）
				
构造函数私有化（单例模式Singleton）
一般来说，构造函数都是放在公有区，要是把构造函数放在私有区在外部都构造不了对象了。在一种特殊情况下，会把构造函数放在私有区，不允许被外界创建对象,我们只需要一个对象即可。
class A{
public:
	static A& getInstance();
	setup(){...}
private:
	A(const A& rhs);
A& A::getInstance(){
	ststic A a;
				
单例模式的类就是在一个进程中只创建一个全局的实例来使用。可以封装一个宏来方便地进行函数调用。
单例模式的构造函数和析构函数都为类的private函数。对外提供一个static方法来获取类的实例。
这样类的实例就无法被其他的类所创建，只能通过对外的static接口来创建该类的实例。
namespace diagservice
	class CDtcInterface
	    pu...
单例模式在开发当中,是将一个项目进行分组编写代码的模式,把描述同一个事物或者对象的属性和方法放在一个封装好的函数(内存空间)当中.
按照我的理解就是，将需要的模块封装在一个内部环境中，暴露出一个接口，而且就算多次调用也都是值返回第一次的执行结果。
const singleTest = function () {
    let ins = null;
    function newIns(i) {
        return i
    return function getIns
				
一般构造函数不是私有或者保护成员，但构造函数可以使私有成员函数，在一些特殊的场合，会把构造函数定义为私有或者保护成员。
C++类的构造函数一般不应该是私有函数，因为私有函数不能被其他类或者全局函数所使用。而创建C++实例需要调用构造函数。
所以如果构造函数是私有函数的话，除了类自己的方法之外，其他类不能构造这个类的实例。一般来说，类做出来就是让其他类使用的，而使用一个类必须先构造它的实例。所以
				
首先，Base、Inner、Top 三个类之间的关系是这样的：Top 是一个类，它包含一个 Inner 类的成员变量，Inner 是一个类，它包含一个 Base 类的成员变量。所以可以说 Inner 是 Top 的内部类，Base 是 Inner 的内部类。
为了给这些类添加构造函数和析构函数，并在函数中加入输出语句，我们可以这样做：
class Base {
 public:
  Base() {
    std::cout << "Base 构造函数" << std::endl;
  ~Base() {
    std::cout << "Base 析构函数" << std::endl;
class Inner {
 public:
  Inner() {
    std::cout << "Inner 构造函数" << std::endl;
  ~Inner() {
    std::cout << "Inner 析构函数" << std::endl;
  Base b;
class Top {
 public:
  Top() {
    std::cout << "Top 构造函数" << std::endl;
  ~Top() {
    std::cout << "Top 析构函数" << std::endl;
  Inner i;
现在我们可以在 main 函数中使用这些类来创建和删除对象，并在函数的各个语句执行前或后加入相应的输出信息，以方便观察构造函数和析构函数的执行情况。
int main() {
  std::cout << "在创建 Top 对象之前" << std::endl;
  Top t;
  std::cout << "在创建 Top 对象之后" << std::endl;
  return 0;
从运行结果中可以看出，在创
				npm ERR! fatal: unable to access ‘https://github.com/adobe-webplatform/eve.git/‘: OpenSSL SSL_read:
					13967