C++中的对象创建限制与单例模式实现-优快云博客

请设计一个类，不能被拷贝

拷贝只会放生在两个场景中：拷贝构造函数以及赋值运算符重载，因此想要让一个类禁止拷贝， 只需让该类不能调用拷贝构造函数以及赋值运算符重载即可。

C++98： 将拷贝构造函数与赋值运算符重载只声明不定义，并且将其访问权限设置为私有即可。

class CopyBan
{
    // ...
    
private:
    CopyBan(const CopyBan&);
    CopyBan& operator=(const CopyBan&);
    //...
};

C++11： C++11扩展delete的用法，delete除了释放new申请的资源外，如果在默认成员函数后跟上 =delete，表示让编译器删除掉该默认成员函数。

class CopyBan
{
    // ...
    CopyBan(const CopyBan&)=delete;
    CopyBan& operator=(const CopyBan&)=delete;
    //...
};

请设计一个类，只能在堆上创建对象

实现方式：

1. 将类的构造函数私有，拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象。

2. 提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建

// 只能在堆上创建对象的类
class HeapOnly
{
public:
	static HeapOnly* CreateObj()
	{
		return new HeapOnly;
	}
private:
	HeapOnly()
	{}

	HeapOnly(const HeapOnly&) = delete;
};

int main()
{
	/*HeapOnly hp1;
	HeapOnly* php2 = new HeapOnly;
	static HeapOnly hp3;*/

	HeapOnly* php4 =  HeapOnly::CreateObj();

	//HeapOnly hp5(*php4);

	delete php4;

	cout << sizeof(php4) << endl;
	cout << sizeof(size_t) << endl;


	return 0;
}

这里注意，要防止拷贝构造，否则禁不住。

请设计一个类，只能在栈上创建对象

方法一：同上将构造函数私有化，然后设计静态方法创建对象返回即可。

class StackOnly
{
public:
    static StackOnly CreateObj()
    {
        return StackOnly();
    }

    void Print() const
	{
		cout << "StackOnly::Print()" << endl;
	}

    // 禁掉operator new可以把下面用new 调用拷贝构造申请对象给禁掉
    void* operator new(size_t size) = delete;
    void operator delete(void* p) = delete;
private:
    StackOnly()
        :_a(0)
    {}
private:
    int _a;
};

int main()
{
	//StackOnly so1 = StackOnly::CreateObj();
	static StackOnly so4 = StackOnly::CreateObj();

	//static StackOnly so2;
	//StackOnly* pso3 = new StackOnly;

	StackOnly::CreateObj().Print();

	const StackOnly& so5 = StackOnly::CreateObj();
	so5.Print();

	return 0;
}

但是只在栈上开辟是有瑕疵的，无法禁止静态对象拷贝构造。

请设计一个类，不能被继承

C++98中构造函数私有化，派生类中调不到基类的构造函数。则无法继承。（不推荐）

C++11方法 final关键字，final修饰类，表示该类不能被继承。

class A  final
{
    // ....
};

RAII锁管理类

template<class Lock>
class LockGuard
{
public:
	LockGuard(Lock& lk)
		:_lk(lk)
	{
		_lk.lock();
	}

	~LockGuard()
	{
		_lk.unlock();
	}

private:
	Lock& _lk;
};

在标准库中使用

请设计一个类，只能创建一个对象(单例模式)

设计模式： 设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。

单例模式： 一个类只能创建一个对象，即单例模式，该模式可以保证系统中该类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。

单例模式有两种实现模式：

饿汉模式

就是说不管你将来用不用，程序启动时就创建一个唯一的实例对象

私有化构造，封死拷贝构造和赋值。

// 单例模式的类：全局只有一个唯一对象
// 饿汉模式：一开始(main函数之前)就创建对象
// 缺点：1、单例对象初始化时数据太多，导致启动慢
//      2、多个单例类有初始化依赖关系，饿汉模式无法控制
class InfoSingleton
{
public:
	static InfoSingleton& GetInstance()
	{
		return _sins;
	}

	void Insert(string name, int salary)
	{
		_info[name] = salary;
	}

	void Print()
	{
		for (auto kv : _info)
		{
			cout << kv.first << ":" << kv.second << endl;
		}
		cout << endl;
	}

private:
	InfoSingleton()
	{}

	InfoSingleton(const InfoSingleton& info) = delete;
	InfoSingleton& operator=(const InfoSingleton& info) = delete;

private:
    map<string, int> _info;
	static InfoSingleton _sins;
};

InfoSingleton InfoSingleton::_sins;

int main()
{

	InfoSingleton::GetInstance().Insert("张三", 10000);
	InfoSingleton& infosl = InfoSingleton::GetInstance();
	infosl.Insert("李四", 15000);
	infosl.Insert("赵六", 12000);
	infosl.Insert("王五", 8000);
	infosl.Print();

	InfoSingleton::GetInstance().Insert("张三", 13000);
	InfoSingleton::GetInstance().Print();

	//InfoSingleton copy = InfoSingleton::GetInstance();
	//copy.Insert("孙七", 50000);
	//copy.Print();

	infosl.Print();

	return 0;
}

注意GetInstance返回的要是引用，封死拷贝构造和赋值，否则单例条件不成立。

懒汉模式

如果单例对象构造十分耗时或者占用很多资源，比如加载插件啊，初始化网络连接啊，读取文件啊等等，而有可能该对象程序运行时不会用到，那么也要在程序一开始就进行初始化，就会导致程序启动时非常的缓慢。所以这种情况使用懒汉模式（延迟加载）更好。

饿汉模式还有一个问题，就是很难控制单例被初始化的顺序，比如A和B都是单例，B依赖A，在文件很多的情况下难以保证先初始化A。所以要解决这个问题，就使用懒汉模式。

// 懒汉模式：第一次获取单例对象的时候创建对象
// 1、对象在main函数之后才会创建，不会影响启动顺序
// 2、可以主动控制创建顺序
class InfoSingleton
{
public:
	// 多个线程一起调用GetInstance，存在线程安全的风险,

	static InfoSingleton& GetInstance()
	{
		// 第一次获取单例对象的时候创建对象
		// 双检查加锁
		if (_psins == nullptr)  // 对象new出来以后，避免每次都加锁的检查，提高性能
		{
			//LockGuard<mutex> lock(_smtx);
			std::lock_guard<mutex> lock(_smtx);

			if (_psins == nullptr)  // 保证线程安全且只new一次
			{
				_psins = new InfoSingleton;
			}	
		}

		return *_psins;
	}

	// 一般单例对象不需要考虑释放
	// 单例对象不用时，必须手动处理，一些资源需要保存
	// 可以手动调用主动回收
	// 也可以让他自己在程序结束时，自动回收
	static void DelInstance()
	{
		// 保存数据到文件
		// ...

		std::lock_guard<mutex> lock(_smtx);
		if (_psins)
		{
			delete _psins;
			_psins = nullptr;
		}
	}

	// 也可以让他自己在程序结束时，自动回收
	class GC
	{
	public:
		~GC()
		{
			if (_psins)
			{
				cout << "~GC()" << endl;
				DelInstance();
			}
		}
	};
	
	void Insert(string name, int salary)
	{
		_info[name] = salary;
	}

	void Print()
	{
		for (auto kv : _info)
		{
			cout << kv.first << ":" << kv.second << endl;
		}
		cout << endl;
	}

private:
	InfoSingleton()
	{}

	InfoSingleton(const InfoSingleton& info) = delete;
	InfoSingleton& operator=(const InfoSingleton& info) = delete;


	map<string, int> _info;
	// ...

private:
	static InfoSingleton* _psins;
	static mutex _smtx;
	static GC _gc;
};

InfoSingleton* InfoSingleton::_psins = nullptr;
mutex InfoSingleton::_smtx;
InfoSingleton::GC InfoSingleton::_gc;

int main()
{

	InfoSingleton::GetInstance().Insert("张三", 10000);
	InfoSingleton& infosl = InfoSingleton::GetInstance();
	infosl.Insert("李四", 15000);
	infosl.Insert("赵六", 12000);
	infosl.Insert("王五", 8000);
	infosl.Print();

	InfoSingleton::GetInstance().Insert("张三", 13000);
	InfoSingleton::GetInstance().Print();

	infosl.Print();
	return 0;
}

使用双检查锁，保证线程安全和效率（只加一次锁）。

实现一个内嵌垃圾回收类GC在不使用单例后释放资源（虽然在本程序中没意义）。

懒汉模式还可以通过局部静态变量初始化实现：

//1、是懒汉。 因为静态的局部变量是在main函数之后才创建初始化的
//2、C++11之前，这里是不能保证sinst的初始化是线程安全的。
//3、C++11之后，可以。
class InfoSingleton
{
public:
	static InfoSingleton& GetInstance()
	{
		static InfoSingleton sinst;
		return sinst;
	}

	void Insert(string name, int salary)
	{
		_info[name] = salary;
	}

	void Print()
	{
		for (auto kv : _info)
		{
			cout << kv.first << ":" << kv.second << endl;
		}
		cout << endl;
	}

private:
	InfoSingleton()
	{
		cout << "InfoSingleton()" << endl;
	}

	InfoSingleton(const InfoSingleton& info) = delete;
	InfoSingleton& operator=(const InfoSingleton& info) = delete;


	map<string, int> _info;
	// ...
};

但是这种方式要慎重，在C++11前不是线程安全的，在C++11后才是线程安全的。