单例模式1

单例模式

单例模式实现步骤
1、将类的构造方法定义为私有方法
2、定义一个私有的类的静态实例对象
3、提供一个公有的获取实例的静态方法

示例单例A,单例B

A.h

#pragma once
#include <iostream>
using namespace std;
class A
{
public:
    static A*instance(){
        if(m_instance == NULL){
            m_instance = new A();
        }
        return m_instance;
    }

    void show(){
        std::cout<<m_name<<std::endl;
    }


private:
    A():m_name("A"){}
    A(const A&){}
    ~A(){}
    A &operator=(const A&);
private:
    string m_name;
    static A*m_instance;

};

A*A::m_instance=nullptr;

B.h

#pragma once
#include <iostream>
using namespace std;
class B
{
public:
    static B*instance(){
        if(m_instance == NULL){
            m_instance = new B();
        }
        return m_instance;
    }

    void show(){
        std::cout<<m_name<<std::endl;
    }


private:
    B():m_name("B"){}
    B(const B&){}
    ~B(){}
    B &operator=(const B&);
private:
    string m_name;
    static B*m_instance;

};

B*B::m_instance=nullptr;

单例调用示例

最简单的单例调用

void test01(){
    A::instance()->show();
    B::instance()->show();
}

调用结果

进阶1-通过 模板+友元 解决A和B的冗余性

模板实现单例

Singleton.h

#pragma once

namespace yazi
{
namespace utility
{

template <typename T>
class Singleton{
public:
    static T*instance(){
        if(m_instance == NULL){
            m_instance = new T();
        }
        return m_instance;
    }
private:
    Singleton(){}
    Singleton(const Singleton<T>&);
    ~Singleton(){}
    Singleton &operator=(const Singleton<T>&);

private:

    static T*m_instance;

};

template <typename T>
T * Singleton<T>::m_instance=NULL;

}
} // namespace yazi

A.h

A.h

#pragma once
#include <iostream>
using namespace std;
#include "Singleton.h"
using namespace yazi::utility;

class A
{
private:
    friend class Singleton<A>;
public:
    void show(){
        std::cout<<m_name<<std::endl;
    }

public:
    A():m_name("Singleton_A1"){}
    A(const A&){}
    ~A(){}
    A &operator=(const A&);
private:
    string m_name;   
};

B.h

B.h

#pragma once
#include <iostream>
using namespace std;
#include "Singleton.h"
using namespace yazi::utility;

class B
{
private:
    friend class Singleton<B>;
public:
    void show(){
        std::cout<<m_name<<std::endl;
    }
public:
    B():m_name("Singleton_B1"){}
    B(const B&){}
    ~B(){}
    B &operator=(const B&);
private:
    string m_name;
};

调用main.cpp

调用

#include<iostream>

using namespace std;
#include"A.h"
#include"B.h"
#include "Singleton.h"
using namespace yazi::utility;

void test01(){
    Singleton<A>::instance()->show();
    Singleton<B>::instance()->show();
}

int main()
{
    test01();

    return 0;
}

调用的运行结果

解决线程安全

通过调用时主动规避

点击查看代码

#include<iostream>

using namespace std;
#include"A.h"
#include"B.h"
#include "Singleton.h"
using namespace yazi::utility;

int main()
{
    // 主线程
    Singleton<A>::instance();
    Singleton<B>::instance();

    //子线程
    Singleton<A>::instance()->show();
    Singleton<B>::instance()->show();

    return 0;
}