写一个单例模式

单例模式：顾名思义就是这个类只能创建一个对象。

让用户调用你的方法，创建对象，而不是通过类名的方法来创建对象。

class Singleton {
public:
	~Singleton() {
		cout << "Singleton() destruct" << endl;
	}
	Singleton* CreateObject() {
		return new Singleton();
	}
private:
	Singleton() {
		cout << "Singleton() construct" << endl;
	}
};

调用函数来返回一个指向对象的指针，但是存在的问题是这个函数需要对象来调用，但是只能通过这个方法创建对象，所以无法执行。

在这个函数前面加上static后，变为静态函数，就不需要对象了。

再次测试

class Singleton {
public:
	~Singleton() {
		cout << "Singleton() destruct" << endl;
	}
	static Singleton* CreateObject() {
		return new Singleton();
	}
private:
	Singleton() {
		cout << "Singleton() construct" << endl;
	}
};
int main(int argc, char** argv) {
	Singleton* s1 = Singleton::CreateObject();
	Singleton* s2 = Singleton::CreateObject();
	return 0;
}

发现每调用一次，就会调用一次new，返回的是新的对象地址。我们只需要一个对象。

那么我们新建一个静态指针变量，让指针的初始值为nullptr；然后如果没创建过对象，就给他new一个地址，然后赋值给这个变量；如果之前已经创建过了，就直接返回即可。

class Singleton {
public:
	~Singleton() {
		cout << "Singleton() destruct" << endl;
	}
	static Singleton* CreateObject() {
		if (m_pObject == nullptr) {
			m_pObject = new Singleton();
		}
		return m_pObject;
	}
private:
	Singleton() {
		cout << "Singleton() construct" << endl;
	}
	static Singleton* m_pObject;
};
Singleton* Singleton::m_pObject = nullptr;
int main(int argc, char** argv) {
	Singleton* s1 = Singleton::CreateObject();
	Singleton* s2 = Singleton::CreateObject();
	return 0;
}

这是懒汉式，同时出现一个重大的问题就是出现了内存泄漏，不会调用类的析构函数。

在主函数中，用完以后还需要将这个对象指针手动释放掉。

而且还处在线程安全问题。

那么应该怎么写

在函数中，创建一个静态的对象，然后将他的地址返回。

class Singleton {
public:
	~Singleton() {
		cout << "Singleton() destruct" << endl;
	}
	static Singleton* CreateObject() {
		static Singleton obj;
		return &obj;
	}
private:
	Singleton() {
		cout << "Singleton() construct" << endl;
	}
	static Singleton* m_pObject;
};
Singleton* Singleton::m_pObject = nullptr;
int main(int argc, char** argv) {
	Singleton* s1 = Singleton::CreateObject();
	Singleton* s2 = Singleton::CreateObject();
	return 0;
}

但是用指针还存在一个问题，如果用户在主函数中delete 这个指针，就会出错。因为这个对象不是在堆中构建的。

那么我们应该怎么做？

那就不返回指针，而是返回引用。

class Singleton {
public:
	~Singleton() {
		cout << "Singleton() destruct" << endl;
	}
	static Singleton& CreateObject() {
		static Singleton obj;
		return obj;
	}
private:
	Singleton() {
		cout << "Singleton() construct" << endl;
	}
	static Singleton* m_pObject;
};
Singleton* Singleton::m_pObject = nullptr;
int main(int argc, char** argv) {
	Singleton& s1 = Singleton::CreateObject();
	Singleton& s2 = Singleton::CreateObject();
	return 0;
}

程序修改为这样

添加监视以后值都是一致的。

但是，如果此时主函数中返回的类型不是引用类型，那就存在了复制构造的过程,引用赋值给了其他对象。

Singleton s2 = Singleton::CreateObject();

说明还需要限制赋值构造函数。

可以将类的拷贝构造函数私有。就是在私有属性中添加拷贝构造函数

	Singleton(Singleton& obj) {
		cout << "Singleton(Singleton& obj) construct" << endl;
	}

此时上面那个存在赋值构造的方法就无法编译通过。

另一个不用私有的方法，把拷贝构造禁用。使用=delete方法

//单例--只有一个实例
class Singleton {
public:
	~Singleton() {
		cout << "Singleton() destruct" << endl;
	}
	static Singleton& CreateObject() {
		static Singleton obj;
		return obj;
	}
	//不允许产生拷贝构造
	Singleton(Singleton& obj) = delete;
	//默认的赋值运算符重载
	Singleton* operator=(Singleton& obj) = delete;
private:
	Singleton() {
		cout << "Singleton() construct" << endl;
	}
};
int main(int argc, char** argv) {
	Singleton& s1=Singleton::CreateObject();
	return 0;
}

日志类可以用单例模式，只有一个日志实例，在程序的任何地方都可以调用这个函数创建日志的这个对象，来写日志。