C++:特殊类设计

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

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

只需让该类不能调用拷贝构造函数以及赋值运算符重载即可 。

原因：

1. 设置成私有：如果只声明没有设置成 private, 用户自己如果在类外定义了,就可以不能禁止拷贝了

2. 只声明不定义：不定义是因为该函数根本不会调用，定义了其实也没有什么意义，不写反而还简单，而且如果定义了就不会防止成员函数内部拷贝了。

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

class HeapOnly
{
public:
	static HeapOnly* CreateObject()
	{
		return new HeapOnly;
	}

	// C++11
	HeapOnly(const HeapOnly&) = delete;
	HeapOnly& operator=(const HeapOnly&) = delete;
private:
	HeapOnly()
	{}
};

int main()
{
	/*HeapOnly obj1;
	static HeapOnly obj2;
	HeapOnly* obj3 = new HeapOnly;*/

	HeapOnly* obj4 = HeapOnly::CreateObject();

	//HeapOnly obj5(*obj4);

	return 0;
}

或者：

class HeapOnly
{
public:
	void Release()
	{
		delete this;
	}
private:
	// 析构私有化
	~HeapOnly()
	{}
};

int main()
{
	//HeapOnly obj1;
	//static HeapOnly obj2;
	HeapOnly* obj3 = new HeapOnly;
	//delete obj3;
	obj3->Release();

	return 0;
}

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

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

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

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

单例模式

单例模式：

一个类只能创建一个对象，即单例模式，该模式可以保证系统中该类只有一个实例，并提供一个

访问它的全局访问点，该实例被所有程序模块共享 。比如在某个服务器程序中，该服务器的配置

信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再

通过这个单例对象获取这些配置信息，这种方式简化了在复杂环境下的配置管理。

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

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

class ConfigInfo
{
public:
	static ConfigInfo* GetInstance()
	{
		return &_sInfo;
	}

	string GetIp()
	{
		return _ip;
	}

	void SetIp(const string& ip)
	{
		_ip = ip;
	}

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

	ConfigInfo(const ConfigInfo&) = delete;
	ConfigInfo& operator=(const ConfigInfo&) = delete;
private:
	string _ip = "127.0.0.1";
	int _port = 80;
	//...

	// 声明 
	static ConfigInfo _sInfo;
};

// 定义
ConfigInfo ConfigInfo::_sInfo;

如果这个单例对象在多线程高并发环境下频繁使用，性能要求较高，那么显然使用饿汉模式来避

免资源竞争，提高响应速度更好。

• 懒汉模式

如果单例对象构造十分耗时或者占用很多资源，比如加载插件啊， 初始化网络连接啊，读取

文件啊等等，而有可能该对象程序运行时不会用到，那么也要在程序一开始就进行初始化，

就会导致程序启动时非常的缓慢。 所以这种情况使用懒汉模式（ 延迟加载 ）更好。

class ConfigInfo
{
public:
	static ConfigInfo* GetInstance()
	{
		// C++11之前，多线程调用GetInstance
		// 局部静态单例对象构造初始化，无法保证线程安全
		// 也就是说，这种写法C++11之后才能用
		static ConfigInfo info;

		return &info;
	}

	string GetIp()
	{
		return _ip;
	}

	void SetIp(const string& ip)
	{
		_ip = ip;
	}

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

	ConfigInfo(const ConfigInfo&) = delete;
	ConfigInfo& operator=(const ConfigInfo&) = delete;
private:
	string _ip = "127.0.0.1";
	int _port = 80;
	//...
};

或者

class ConfigInfo
{
public:
	static ConfigInfo* GetInstance()
	{
		// C++11之前也能保证线程安全
		// 多线程调用需要考虑线程安全问题

		// 双检查加锁
		// t1 t2
		if (_spInfo == nullptr)      // 性能
		{
			unique_lock<mutex> lock(_mtx);
			if (_spInfo == nullptr)  // 线程安全
			{
				_spInfo = new ConfigInfo;
			}
		}

		return _spInfo;
	}

	string GetIp()
	{
		return _ip;
	}

	void SetIp(const string& ip)
	{
		_ip = ip;
	}

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

	ConfigInfo(const ConfigInfo&) = delete;
	ConfigInfo& operator=(const ConfigInfo&) = delete;
private:
	string _ip = "127.0.0.1";
	int _port = 80;
	//...
 
	static ConfigInfo* _spInfo;
	static mutex _mtx;
};

ConfigInfo* ConfigInfo::_spInfo = nullptr;
mutex ConfigInfo::_mtx;