请设计一个类,不能被拷贝
拷贝只会放生在两个场景中:拷贝构造函数以及赋值运算符重载,因此
想要让一个类禁止拷贝,
只需让该类不能调用拷贝构造函数以及赋值运算符重载即可
。
![](https://i-blog.csdnimg.cn/direct/c759b84be618470c904daf2badb1117a.png)
原因:
1.
设置成私有:如果只声明没有设置成
private,
用户自己如果在类外定义了,就可以不能禁止拷贝了
2.
只声明不定义:不定义是因为该函数根本不会调用,定义了其实也没有什么意义,不写反而还简单,而且如果定义了就不会防止成员函数内部拷贝了。
![](https://i-blog.csdnimg.cn/direct/c4521e7933dd435894b9692dcb8f5a10.png)
请设计一个类,只能在堆上创建对象
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;