C++：单例模式

class Foo {
public:
	//针对任意类型的任意成员变量，写出基本的Set/Get函数
	string GetName() { return name; }//❗
	void SetName(string str) { name = str; }//❗
	static Foo* GetInstance() {
		if (_instance == nullptr)//❗
			_instance = new Foo;//❗
		return _instance;
	}
private:
	static Foo* _instance; //指向了唯一的对象❗
	Foo() {};//私有构造函数//❗
	string name;
};
//常函数const 类外实现要写

//int a=0;
Foo* Foo::_instance = nullptr;//考❗

//Set/Get类外实现

void Fun() {
	Foo* p1 = Foo::GetInstance();//考❗
}

int main()
{
	Foo* p1 = Foo::GetInstance();//❗
	p1->SetName("Bob");
	Fun();
	cout << p1->GetName() << endl;
}

• 创建自己的对象，同时确保对象的唯一性。

• 单例类只能有一个实例☞静态成员static☞静态成员 必须类外初始化

• 单例类必须自己创建自己的唯一实例

• 单例类必须给所有其他对象提供这一实例

• 静态成员类内部可以访问

1.  构造函数私有化☞构造函数私有外部不能创建，但是内部可以创建
2. 内部需要封装一个唯一实例的指针
3. 针对成员变量_instance设计静态成员函数GetInstance/Setinstance

Singleton.h

#pragma once
#include<string>
using namespace std;
class Singleton
{
public:
	static Singleton* GetInstance();❗
	void SetName(const char* str);❗
	string GetName();❗
private:
	Singleton();//构造函数
	static Singleton* _instance;//唯一对象的指针❗
	string name;//针对name有一套set get函数考
};

Singleton.cpp

#include "Singleton.h"

//类外构造函数，成员函数初始化❗
Singleton::Singleton() {
}


//成员变量初始化,不用加上static
Singleton* Singleton::_instance = nullptr; //考❗


//定义Getinstance 类外实现不用再加上static
Singleton* Singleton::GetInstance() {
	if (_instance == nullptr)
		_instance = new Singleton; //类的内部创建考❗
	return _instance;
}

//setname定义❗
void Singleton::SetName(const char* str)
{
	name = str;
}


//Getname定义❗
string Singleton::GetName()
{
	return name;
}

main.cpp

#include<iostream>
#include"Singleton.h"

void fun()
{
	Singleton* p = Singleton::GetInstance();
	p->SetName("Alice");
}
int main()
{
	Singleton* q = Singleton::GetInstance();//考❗
	q->SetName("Bob");
	fun();
	cout << q->GetName() << endl;
}