Cpp::特殊类的设计(35)
文章目录
- 前言
- 一、设计一个不能被拷贝的类
- 二、设计一个只能在堆上创建对象的类
- 三、设计一个只能在栈上创建对象的类
- 四、设计一个不能被继承的类
- 五、请设计一个类，只能创建一个对象（单例模式）
- 总结
前言
加油加油，终于要结束了！
一、设计一个不能被拷贝的类
首先我们要明确什么时候会发生拷贝：
- 拷贝构造函数
- 赋值运算符重载
因此想要让一个类禁止拷贝，只需让该类不能调用拷贝构造函数以及赋值运算符重载即可
比如说来个例子 ostream 就规定不能被拷贝
int main()
{
ostream os(nullptr);
// 不支持拷贝构造
//ostream os1(os);
return 0;
}
至于怎么做到，请看如下：
在C++98中
将拷贝构造函数与赋值运算符重载只声明不定义，并且将其访问权限设置为私有即可
// 不能被拷贝的类
class CopyBan
{
public:
// 强制生成默认构造，写了拷贝构造不会自动生成默认构造
CopyBan() = default;
// ...
private:
CopyBan(const CopyBan&);
CopyBan& operator=(const CopyBan&);
//...
};
int main()
{
CopyBan cb;
// 不能拷贝
//CopyBan cb1(cb);
// 不能赋值重载
CopyBan cb2;
//cb2 = cb;
return 0;
}
设置成私有：如果只声明没有设置成private，用户自己如果在类外定义了，就可以不能禁止拷贝了
只声明不定义：不定义是因为该函数根本不会调用，定义了其实也没有什么意义，不写反而还简单，而且如果定义了就不会防止成员函数内部拷贝了
在C++11中
C++11扩展delete的用法，delete除了释放new申请的资源外，如果在默认成员函数后跟上 =delete，表示让编译器删除掉该默认成员函数
class CopyBan
{
public:
CopyBan() = default;
//...
CopyBan(const CopyBan&) = delete;
CopyBan& operator=(const CopyBan&) = delete;
//...
};
int main()
{
CopyBan cb;
// 不能拷贝
//CopyBan cb1(cb);
// 不能赋值重载
CopyBan cb2;
//cb2 = cb;
return 0;
}
二、设计一个只能在堆上创建对象的类
只能在堆上创建对象，也就是只能通过new操作符创建对象，具体方法如下：
- 将构造函数设置为私有，防止外部直接调用构造函数在栈上创建对象
- 向外部提供一个获取对象的static接口，该接口在堆上创建一个对象并返回
- 将拷贝构造函数设置为私有，并且只声明不实现，防止外部调用拷贝构造函数在栈上创建对象
// 只能在堆上创建的类
class OnlyHeap
{
public:
static OnlyHeap* CreateObj()
{
return new OnlyHeap;
}
// C++11 不允许生成拷贝构造和赋值
OnlyHeap(const OnlyHeap&) = delete;
OnlyHeap& operator=(const OnlyHeap&) = delete;
private:
// 构造函数私有
OnlyHeap()
{}
};
int main()
{
// 不能直接实例化对象
//OnlyHeap obj1;
// 通过静态成员函数new对象
OnlyHeap* p1 = OnlyHeap::CreateObj();
// 可以调用拷贝构造实例化对象，加delete则不能生成对象
//OnlyHeap obj2(*p1);
// 不能直接new对象
//OnlyHeap* p2 = new OnlyHeap;
return 0;
}
向外部提供的CreateObj函数必须设置为静态成员函数，因为外部调用该接口就是为了获取对象的，而非静态成员函数必须通过对象才能调用
是鸡先生蛋，还是蛋先生鸡？
其实，我们还有另外一种方法，就是直接将析构函数私有
class OnlyHeap
{
public:
void Release()
{
delete this;
}
private:
// 将析构私有
~OnlyHeap()
{}
int _a = 1;
};
int main()
{
// 不能直接实例化对象
//OnlyHeap obj1;
OnlyHeap* p1 = new OnlyHeap;
// 无法访问析构函数
//delete p1;
p1->Release();
return 0;
}
三、设计一个只能在栈上创建对象的类
方法一是将构造函数私有化，然后设计静态方法创建对象返回即可
// 只能在栈区创建对象
class StackOnly
{
public:
static StackOnly CreateObj()
{
return StackOnly();
}
private:
StackOnly()
:_a(0)
{}
private:
int _a;
};
int main()
{
StackOnly obj = StackOnly::CreateObj();
// 但是有个弊端：无法防止外部调用拷贝构造函数创建对象
// 那为什么不考虑把拷贝构造函数设为私有或者删除？
// 因为CreateObj函数当中创建的是局部对象
// 返回局部对象的过程中势必需要调用拷贝构造函数
// StackOnly* p1 = new StackOnly(obj);
return 0;
}
方法二是将 operator new 和 operator delete 给 delete 掉
class StackOnly
{
public:
StackOnly()
{}
private:
//C++98
void* operator new(size_t size);
void operator delete(void* p);
//C++11
//void* operator new(size_t size) = delete;
//void operator delete(void* p) = delete;
};
不妨我们再来回顾一下 new 和 delete 的原理
- new在堆上申请空间实际分为两步，第一步是调用operator new函数申请空间，第二步是在申请的空间上执行构造函数，完成对象的初始化工作
- delete在释放堆空间也分为两步，第一步是在该空间上执行析构函数，完成对象中资源的清理工作，第二步是调用operator delete函数释放对象的空间
new和delete默认调用的是全局的operator new函数和operator delete函数，但如果一个类重载了专属的operator new函数和operator delete函数，那么new和delete就会调用这个专属的函数。所以只要把operator new函数和operator delete函数屏蔽掉，那么就无法再使用new在堆上创建对象了
但是问题在于，既然把构造函数给放开，那我们又无法避免在静态区创建变量了
static StackOnly obj; //在静态区创建对象
四、设计一个不能被继承的类
在C++98中
将该类的构造函数设置为私有即可，因为子类的构造函数被调用时，必须调用父类的构造函数初始化父类的那一部分成员，但父类的私有成员在子类当中是不可见的，所以在创建子类对象时子类无法调用父类的构造函数对父类的成员进行初始化，因此该类被继承后子类无法创建出对象
class NonInherit
{
public:
static NonInherit CreateObj()
{
return NonInherit();
}
private:
//将构造函数设置为私有
NonInherit()
{}
};
在C++11中
C++98的这种方式其实不够彻底，因为这个类仍然可以被继承（编译器不会报错），只不过被继承后无法实例化出对象而已。于是C++11中提供了final关键字，被final修饰的类叫做最终类，最终类无法被继承，此时就算继承后没有创建对象也会编译出错
class NonInherit final
{
//...
};
五、请设计一个类，只能创建一个对象（单例模式）
什么是单例模式？
- 单例模式是一种设计模式（Design Pattern），设计模式就是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式的目的就是为了可重用代码、让代码更容易被他人理解、保证代码可靠性程序的重用性
- 单例模式指的就是一个类只能创建一个对象，该模式可以保证系统中该类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享
- 比如在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象同一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息，这种方式简化了在复杂环境下的配置管理
第一种实现方式：饿汉模式
- 将构造函数设置为私有，并将拷贝构造函数和赋值运算符重载函数设置为私有或删除，防止外部创建或拷贝对象
- 提供一个指向单例对象的static指针，并在程序入口之前完成单例对象的初始化
- 提供一个全局访问点获取单例对象
// 1、多个饿汉模式的单例，某个对象初始化内容较多(读文件)，会导致程序启动慢
// 2、A和B两个饿汉，对象初始化存在依赖关系，要求A先初始化，B再初始化，饿汉无法保证
class InfoMgr
{
public:
static InfoMgr& GetInstance()
{
return _ins;
}
void Print()
{
cout << _ip << endl;
cout << _port << endl;
cout << _buffSize << endl;
}
private:
InfoMgr(const InfoMgr&) = delete;
InfoMgr& operator=(const InfoMgr&) = delete;
InfoMgr()
{
cout << "InfoMgr()" << endl;
}
private:
string _ip = "127.0.0.1";
int _port = 80;
size_t _buffSize = 1024 * 1024;
//...
static InfoMgr _ins;
};
InfoMgr InfoMgr::_ins;
int main()
{
InfoMgr::GetInstance().Print();
//InfoMgr copy(InfoMgr::GetInstance());
return 0;
}
第二种实现方式：懒汉模式
- 将构造函数设置为私有，并将拷贝构造函数和赋值运算符重载函数设置为私有或删除，防止外部创建或拷贝对象
- 提供一个指向单例对象的static指针，并在程序入口之前先将其初始化为空
- 提供一个全局访问点获取单例对象
class InfoMgr
{
public:
static InfoMgr& GetInstance()
{
// 第一次调用时创建单例对象
// 线程安全的风险
if (_pins == nullptr)
{
_pins = new InfoMgr;
}
return *_pins;
}
void Print()
{
cout << _ip << endl;
cout << _port << endl;
cout << _buffSize << endl;
}
static void DelInstance()
{
delete _pins;
_pins = nullptr;
}
private:
InfoMgr(const InfoMgr&) = delete;
InfoMgr& operator=(const InfoMgr&) = delete;
InfoMgr()
{
cout << "InfoMgr()" << endl;
}
private:
string _ip = "127.0.0.1";
int _port = 80;
size_t _buffSize = 1024 * 1024;
//...
static InfoMgr* _pins;
};
InfoMgr* InfoMgr::_pins = nullptr;
int main()
{
InfoMgr::GetInstance().Print();
InfoMgr::GetInstance().Print();
return 0;
}
总结
这么样，不难吧！