目录
一、请设计一个类,不能被拷贝
cpp
//设计一个类没有不能被拷贝
class CopyBan
{
public:
//...
CopyBan(CopyBan& cb) = delete;
CopyBan& operator=(CopyBan& cb) = delete;
};
二、请设计一个类,只能在堆上创建对象
cpp
//设计一个类只能在堆上创建
class HeapOnly
{
public:
static HeapOnly* Create()
{
return new HeapOnly;
}
HeapOnly(HeapOnly& ho) = delete;
private:
HeapOnly()
{}
};
int main()
{
HeapOnly* pho=HeapOnly::Create();
//如果不封拷贝这样就在栈上创建对象了
HeapOnly copy(*pho);
}
注意这里要将拷贝构造禁掉,
三、请设计一个类,只能在栈上创建对象
cpp
//设计一个类只能在栈上创建
class StackOnly
{
public:
static StackOnly CreateObj()
{
return StackOnly();
}
//不能禁掉拷贝构造
//StackOnly(StackOnly& so) = delete;
void* operator new(size_t size) = delete;
void operator delete(void* p) = delete;
private:
StackOnly()
{}
};
四、请设计一个类,不能被继承
cpp
// C++98中构造函数私有化,派生类中调不到基类的构造函数。则无法继承
class NonInherit
{
public:
static NonInherit GetInstance()
{
return NonInherit();
}
private:
NonInherit()
{}
};
五、请设计一个类,只能创建一个对象(单例模式)
5.1饿汉模式
就是说不管你将来用不用,程序启动时就创建一个唯一的实例对象。
cpp
// 优点:简单
// 缺点:可能会导致进程启动慢,且如果有多个单例类对象实例启动顺序不确定。
//饿汉模式
class Singleton
{
public:
static Singleton& CreateObj()
{
return _s;
}
private:
static Singleton _s;
Singleton()
{}
Singleton(const Singleton& s) = delete;
Singleton& operator=(const Singleton& s) = delete;
};
Singleton Singleton::_s;
5.2懒汉模式
如果单例对象构造十分耗时或者占用很多资源,比如加载插件啊, 初始化网络连接啊,读取文件啊等等,而有可能该对象程序运行时不会用到,那么也要在程序一开始就进行初始化,就会导致程序启动时非常的缓慢。 所以这种情况使用懒汉模式(延迟加载)更好。
cpp
// 懒汉
// 优点:第一次使用实例对象时,创建对象。进程启动无负载。多个单例实例启动顺序自由控
制。
// 缺点:复杂
namespace lazy
{
class Singleton
{
public:
static Singleton* CreateObj()
{
if (_s == nullptr)
{
_s = new Singleton;
}
return _s;
}
void DelSingleton()
{
if (_s)
{
delete _s;
_s = nullptr;
}
}
private:
static Singleton* _s;
Singleton()
{}
Singleton(const Singleton& s) = delete;
Singleton& operator=(const Singleton& s) = delete;
};
Singleton* Singleton::_s = nullptr;
class GC
{
public:
~GC()
{
Singleton::CreateObj()->DelSingleton();
}
};
}