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
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
{
public:
	friend class Singleton;
private:
	A() {};
	~A() {};

};


int main()
{

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

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

template
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
{
	friend class Singleton;
private:
	A() {};
	~A() {};

};

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

template
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::value)
	{
		static T instance{};  

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

};