C++ 单例

众所周知，网上一直流传着，不知道叫什么的单例，乱七八糟写啥的都有。单例就始终保持一个实例。在C++ 中实现，我们就只要注意两点。哪里两点？拷贝构造，拷贝复制这两点。

C++ 默认类中，会包含六个构造函数。我们只要把上面这两个禁用掉就没问题了。用新特性（=delete）。有人说，“啊，我们用的什么类模板，有new” 这哪的。今天就用这个写了。

class Singleton
{
public:
	static Singleton& GetInstance()
	{
		static Singleton instance;

		return instance;

	}
	Singleton(const Singleton&) = delete; //这个叫拷贝构造
	Singleton& operator =(const Singleton&) = delete;//拷贝赋值
	~Singleton() {};

private:
	Singleton() {}; //默认构造函数
};


class A      //有些人可能会这么写，这是不是也可以。
{
public:

	static A& GetInstance();

private:
	A() {};
	A(const A& rts);
};

A& A::GetInstance()
{
	static A a;
	return a;
}



int main()
{
	Singleton& sing = Singleton::GetInstance(); //得到一个实例

	A &a = A::GetInstance();
}

这是不是完全体现了C++ Class类应用的成果。

这个是我根据编译器的提示改出来的。这是不是，不太对，虽然能通过编译，但是，是不是违背了始终保持一个实例的约定。写私有报错，写共有的违背了约定。

template<typename T>
class Singleton
{
public:
	static T& GetInstance()
	{
		static T instance;
		return instance;
	}
	Singleton() { cout << "this is construction"; };  //共有的构造   //这两行错了
	~Singleton() {};                            //虚的析构没写
	Singleton(const Singleton& ) = delete;
	Singleton& operator = (const Singleton & ) = delete;
private:
	//Singleton() { cout << "this is construction"; };  写这里报错 访问不到
};
class A :public Singleton<A>
{
public:
	friend class Singleton<A>;
private:
	A() {};
	~A() {};

};


int main()
{

	A& a = Singleton<A>::GetInstance();
	A& b = Singleton<A>::GetInstance();
}

那么，再看这个，修改好的单例。这一下，友元，私有，共有，继承，受保护的全上了。虚析构也有了。这。。完美了吗？应该是的。还有没有更高的。有！

template<typename T>
class Singleton
{
public:
	static T& GetInstance()
	{
		static T instance;
		return instance;
	}

protected:
	Singleton() { cout << "this is construction"; };  //必须的
	virtual ~Singleton() {};
	Singleton(const Singleton& ) = delete;
	Singleton& operator = (const Singleton & ) = delete;

};
class A :public Singleton<A>
{
	friend class Singleton<A>;
private:
	A() {};
	~A() {};

};

下面这个，正常人应该都写不出来。毕竟每个人水平的高低，使用的程度都是不一样的。谁每天的去扒拉一堆新特性。仔细的一看，这不是跟你上面那个一样吗。是的。。但，多了很多约定。提供了更好的保障性。

template<typename T>
class Singleton
{
protected:
	Singleton()noexcept = default;

	Singleton(const Singleton&) = delete;

	Singleton& operator =(const Singleton&) = delete;

	virtual ~Singleton()noexcept = default;

public:

	static T& GetInstance()noexcept(std::is_nothrow_constructible<T>::value)
	{
		static T instance{};  

		return instance;
	}
	
};
class A :public Singleton<A>
{
//public:
	friend class Singleton<A>;
	
private:
	A() {};
	~A() {};

};

猜你喜欢