单例模式、构造函数、左值右值

拷贝构造函数

简单的说就是——用一个对象构造另外一个对象

class Myclass
{
	public:
		int d=0;
		Myclass(int d_){d = d_};	//常用的构造函数
		Myclass(Myclass c) //拷贝构造函数
		{
			d = c.d;
		}
};
//对比
class Myclass
{
	public:
		int d=0;
		Myclass(int d_){d = d_};	//常用的构造函数
		Myclass(const Myclass& c) //高效安全的拷贝构造函数
		{
			d = c.d;
		}
};
//调用
int main()
{
	Myclass A(3);
	Myclass B(A);
}

简单的说一下，main中展示了两种构造对象的方式：
一种是用了一般构造函数，构造了对象A
一种是用了拷贝构造函数，利用A构造了对象B
这里注意一下，对比 展示了拷贝构造函数的写法，后者传入参数用了常引用，避免了一次形参到实参的拷贝，同时const保护了A在函数内不被意外修改。

左值右值(会转换)

左值：c++中可以取地址的，有名字的。

右值： 不可取地址，无名字

左值k变右值：std::move(k);

移动构造函数

先给一个简单的例子

class A
{
	public:
		int* a;
		A(){a=new int(2);}//普通的构造函数
		A(A&& a_out){a = a_out.a;a_out.a =nullptr;}//移动构造
		A(const A& c_){a = c_.a;c_.a = nullptr;};//拷贝构造
		~A(){if(a!=nullptr)delete a;}//析构函数
};
int main()
{
	A k = A();
  A ak = k;		
  A ck = std::move(ak);
}

这里A&& 类型我们称为右值引用。

A k = A();显然 A() 先调用了普通的构造函数，然而由于是个右值(因为没有变量)。用来初始化k对象，这里就调用了移动构造

我们利用左值k来初始化ak对象，显然就是拷贝构造。

最后虽然ak是左值，但是move运算后得到右值，所以也是移动构造。

单例模式——懒汉模式(只有在调用的时候才初始化)

class Singletem
{
	public:
		static Singletem& getitem()
		{
			static Singletem it;
			return it;
		}	
		Singletem(const Singletem & itt) = delete;//禁用拷贝构造；
		Singletem(Singletem && itt) = delete;//禁用移动构造
		Singletem& operator=(const Singletem & itt) = delete; //禁用拷贝赋值运算符
		//例如 Singletem A; Singletem B;
		// A = B;
		Singletem& operator=(Sinletem&& itt) = delete;//禁用移动赋值运算符  
		//例如 Singletem A;
		// A = Singletem();
	private:
	  Singletem();
};
或者写作
class noncopyable
{
protected:
    noncopyable() = default;
    ~noncopyable() = default;
		noncopyable(const noncopyable & itt) = delete;//禁用拷贝构造；
		noncopyable(noncopyable && itt) = delete;//禁用移动构造
		noncopyable& operator=(const noncopyable & itt) = delete; //禁用拷贝赋值运算符
		noncopyable& operator=(noncopyable&& itt) = delete;//禁用移动赋值运算符  
}
class Singletem:noncopyable
{
	public:
		static Singletem& getitem()
		{
			static Singletem it;
			return it;
		}	
	private:
	  Singletem();
};

这里有一个小细节，operator返回的是引用，这是为了链式法则，例如a=b=2;

单例模式——饿汉模式(未经调用就先初始化)

class Singletem:noncopyable
{
	public:
		static Singletem& getitem()
		{
			static Singletem it;
			return it;
		}	
	private:
	  static Singletem tem;
	  Singletem();
};
Singletem Singletem::tem;//实例初始化
int main()
{
Singletem s1 = Singletem::getitem();
Singletem s2 = Singletem::getitem();
bool c= &s1==&s2;
return 1;
}