C++11 使用智能指针改进单例模式

秒速五厘米 2023-01-06 11:51 146阅读 0赞

本文主要关于如何使用C++11的智能指针改进单例模式。智能指针在C++11版本之后提供，包含在头文件中，shared\_ptr、unique\_ptr、weak\_ptr。改进单例模式的初衷：线程安全、垃圾回收、单例对象可接受多个参数。

## 1、使用shared\_ptr ##

相对于一般的单例实现而言，使用了可变参数模板使得单例对象可接受多个参数：

#pragma once
    #include <mutex>
    #include <memory>
    
    template<typename T>
    class SingletonT 
    { 
    public:
    	//GetInstance
    	template<typename ...Args>
    	static std::shared_ptr<T> GetInstance(Args&&... args) { 
    		if (!sington_) { 
    			std::lock_guard<std::mutex> lock(mutex_);
    			if (nullptr == sington_) { 
    				sington_ = std::make_shared<T>(std::forward<Args>(args)...);
    			}
    		}
    		return sington_;
    	}
    
    	//DelInstance
    	static void DelInstance() { 
    		std::lock_guard<std::mutex> lock(mutex_);
    		if (sington_) { 
    			sington_.reset();
    			sington_ = nullptr;
    		}
    	}
    
    private:
    	SingletonT() = default;	
    	SingletonT(const SingletonT&) = delete;
    	SingletonT& operator=(const SingletonT&) = delete;
    	~SingletonT() = default;
    
    private:
    	static std::shared_ptr<T> sington_;
    	static std::mutex mutex_;
    };
    
    template<typename T>
    std::shared_ptr<T> SingletonT<T>::sington_ = nullptr;
    
    template<typename T>
    std::mutex SingletonT<T>::mutex_;

## 2、使用unique\_ptr ##

相对于 shared\_ptr，使用 unique\_ptr 本人觉得更具优势，主要基于以下几点：

*  使用 std::call\_once 使得函数可以线程安全的只调用一次
 *  使用 unique\_ptr 控制对象析构，而shared\_ptr会多一个引用计数，占用空间
 *  可变参数模板使得单例对象可接受多个参数

#pragma once
    #include <mutex>
    #include <memory>
    
    template<typename T>
    class SingletonLazy
    { 
    public:
    	/*static T& Instance() { static std::once_flag flag; std::call_once(flag, [&]() { instance_.reset(new T); }); return *instance_; }*/
    	
    	template<typename... Args>
    	static T& Instance(Args&&...args)
    	{ 
    		static std::once_flag flag;
    		std::call_once(flag, [&]() { 
    			instance_.reset(new T(std::forward<Args>(args)...));
    		});
    		return *instance_;
    	}
    
    	static std::unique_ptr<T> instance_;
    
    private:
    	SingletonLazy() = default;
    	SingletonLazy(const SingletonLazy&) = delete;
    	SingletonLazy& operator=(const SingletonLazy&) = delete;
    	~SingletonLazy() = default;
    };
    template<typename T>
    std::unique_ptr<T> SingletonLazy<T>::instance_;

## 3、测试代码 ##

#include "singleton.h"
    #include <iostream>
    using namespace std;
    
    
    class MyClass
    { 
    public:
    	MyClass()
    	{ 
    		cout << "MyClass()" << endl;
    	};
    
    	virtual ~MyClass()
    	{ 
    		cout << "~MyClass()" << endl;
    	};
    
    	void fun()
    	{ 
    		cout << "this is fun." << endl;
    	}
    	void fun2()
    	{ 
    		cout << "this is fun2." << endl;
    	}
    private:
    	string m_strData;
    };
    
    
    class MyClass1 
    { 
    public:
    	MyClass1(const string& data) : data_(data)
    	{ 
    		//cout << "MyClass1 Constructor" << endl;
    		cout << data_.data() << endl;
    	};
    
    	virtual ~MyClass1()
    	{ 
    		cout << "MyClass Destructor" << endl;
    	};
    
    	void fun()
    	{ 
    		cout << "this is fun." << endl;
    	}
    	void fun2()
    	{ 
    		cout << "this is fun2." << endl;
    	}
    private:
    	string data_;
    };
    
    
    int main()
    { 
    	std::cout << "Hello World!\n";
    	
    	//SingletonT(std::shared_ptr方式)
    	auto _inst = SingletonT<MyClass1>::GetInstance("MyClass1 Constructor");
    	SingletonT<MyClass1>::DelInstance();
    
    	//SingletonLazy(std::unique_ptr + std::call_once)
    	auto instMyClass1 = SingletonLazy<MyClass1>::Instance("MyClass1");
    	instMyClass1.fun();
    	instMyClass1.fun2();
    
    	auto instMyClass = SingletonLazy<MyClass>::Instance();
    	instMyClass.fun();
    	instMyClass.fun2();
    
    	system("pause");
    	return 1;
    }