文章目录
正文开始前给大家推荐个网站,前些天发现了一个巨牛的 人工智能 学习网站, 通俗易懂,风趣幽默 ,忍不住分享一下给大家。 点击跳转到网站。
设计一个不能被拷贝的类
拷贝只会放生在两个场景中:拷贝构造函数以及赋值运算符重载,因此想要让一个类禁止拷贝,只需让该类不能调用拷贝构造函数以及赋值运算符重载即可。
C++98中可以将拷贝构造和赋值重载私有化即可。
cpp
class copyban
{
public:
//...
private:
copyban(const copyban& c);
copyban& operator+(const copyban& c);
//...
};
- 设置成私有:如果只声明没有设置成private,用户自己如果在类外定义了,就可以不能禁止拷贝了
- 只声明不定义:不定义是因为该函数根本不会调用,定义了其实也没有什么意义,不写反而还简单,而且如果定义了就不会防止成员函数内部拷贝了。
C++11中可以直接把拷贝构造和赋值重载禁止生成。
cpp
class copyban
{
public:
//...
copyban(const copyban& c) = delete;
copyban& operator+(const copyban& c) = delete;
private:
//...
};
设计一个只能在堆上创建对象的类
- 将类的构造函数私有,拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象。
- 提供一个静态的成员函数,在该静态成员函数中完成堆对象的创建
cpp
class HeapOnly
{
public:
static HeapOnly* CreateObject()
{
return new HeapOnly;
}
private:
HeapOnly() {}
// C++98
// 1.只声明,不实现。因为实现可能会很麻烦,而你本身不需要
// 2.声明成私有
HeapOnly(const HeapOnly&);
// or
// C++11
HeapOnly(const HeapOnly&) = delete;
};
也可以将析构函数给私有化,拷贝构造仍然需要禁用。
cpp
class HeapOnly
{
public:
HeapOnly() {};
static HeapOnly* CreateObject()
{
return new HeapOnly;
}
static void Del(HeapOnly* del)
{
delete del;
}
private:
~HeapOnly();
// C++98
// 1.只声明,不实现。因为实现可能会很麻烦,而你本身不需要
// 2.声明成私有
HeapOnly(const HeapOnly&);
// or
// C++11
HeapOnly(const HeapOnly&) = delete;
};
设计一个只能在栈上创建对象的类
同上将构造函数私有化,然后设计静态方法创建对象返回即可。但是别人可能用这个对象来在堆上new一个对象,但是拷贝构造不能禁用,不然静态方法没法返回,所以需要把operator new禁用一下。
cpp
class StackOnly
{
public:
static StackOnly CreateObj()
{
return StackOnly();
}
// 禁掉operator new可以把用new 调用拷贝构造申请对象给禁掉
void* operator new(size_t size) = delete;
private:
StackOnly()
:_a(0)
{}
private:
int _a;
};
不能被继承的类
- 构造函数私有化,派生类中调不到基类的构造函数。则无法继承。
- final关键字,final修饰类,表示该类不能被继承。
设计模式
设计模式(Design Pattern)是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。
使用设计模式的目的:为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。 设计模式使代码编写真正工程化;设计模式是软件工程的基石脉络,如同大厦的结构一样。
单例模式
一个类只能创建一个对象,即单例模式,该模式可以保证系统中该类只有一个实例,并提供一个访问它的全局访问点,该实例被所有程序模块共享。比如在某个服务器程序中,该服务器的配置信息存放在一个文件中,这些配置数据由一个单例对象统一读取,然后服务进程中的其他对象再通过这个单例对象获取这些配置信息,这种方式简化了在复杂环境下的配置管理。
单例模式有两种实现模式:
饿汉模式
就是说不管你将来用不用,程序启动时就创建一个唯一的实例对象。
首先整个程序中只能有一个对象,我们一定是要将构造函数给私有化的,不然用户就可以在外面随便创建对象,但是唯一的一个对象要在程序启动的时候就已经创建了,只有全局对象在程序启动时就已经创建好了,所以我们这个对象一定是要在全局创建的,但是因为构造函数私有了,所以这个对象在全局也是没法创建的,所以我们可以考虑创建一个静态创建成员变量,因为每个对象的成员不包括静态成员变量,所以不存在自己包含自己的问题。静态成员变量相当于有了类域的全局变量。
cpp
//饿汉模式
class singleton
{
public:
static singleton* GetInstance()
{
return &_s;
}
private:
//构造函数私有
singleton() {};
//还需要仿拷贝
singleton(const singleton& s) = delete;
singleton& operator=(const singleton& s) = delete;
//全局唯一的一个对象
static singleton _s;
//需要的成员
//..
};
//在程序运行前就初始化了
singleton singleton::_s;
优点:简单
缺点:可能会导致进程启动慢,且如果有多个单例类对象实例启动顺序不确定
如果这个单例对象在多线程高并发环境下频繁使用,性能要求较高,那么显然使用饿汉模式来避免资源竞争,提高响应速度更好。
懒汉模式
懒汉模式是你什么时候用这个对象什么时候创建,不需要程序开始时就一定创建好。
懒汉的实现和饿汉相似,只不过把静态成员变量定义成指针就好了。
cpp
//懒汉模式
class singleton
{
public:
static singleton* GetInstance()
{
if (_s == nullptr)
{
return new singleton();
}
return _s;
}
private:
//构造函数私有
singleton() {};
//还需要仿拷贝
singleton(const singleton& s) = delete;
singleton& operator=(const singleton& s) = delete;
//全局唯一的一个对象
static singleton* _s;
//需要的成员
//..
};
//在程序运行前就初始化了
singleton* singleton::_s = nullptr;
懒汉是不需要我们自己手动释放资源的,因为当需要释放的时候,该进程一般就要结束了,系统会自己释放的。但是有一些情况时需要我们自己提前释放的,我们提供以个释放的函数就行了,在提供一个内部类进行释放就可以了。
优点:第一次使用实例对象时,创建对象。进程启动无负载。多个单例实例启动顺序自由控制。
缺点:复杂
如果单例对象构造十分耗时或者占用很多资源,比如加载插件啊, 初始化网络连接啊,读取文件啊等等,而有可能该对象程序运行时不会用到,那么也要在程序一开始就进行初始化,就会导致程序启动时非常的缓慢。 所以这种情况使用懒汉模式(延迟加载)更好。