目录
序言
（一）设计一个不能被拷贝的类
（二）设计一个只能在堆上创建对象的类
（三）设计一个只能在栈上创建对象的类
（四）设计一个不能被继承的类
总结
序言
特殊类设计是指在面向对象编程中，根据特定需求或情况，创建具备特殊功能或属性的类。特殊类设计旨在解决特定问题或满足特殊需求，使代码更加灵活和可扩展。
（一）设计一个不能被拷贝的类
拷贝只会放生在两个场景中：拷贝构造函数以及赋值运算符重载，因此想要让一个类禁止拷贝，只需让该类不能调用拷贝构造函数以及赋值运算符重载即可。
接下来，我们分别从C++98和C++11的两种场景去看二者是如何实现：
【C++98】：将拷贝构造函数与赋值运算符重载只声明不定义，并且将其访问权限设置为私有即可
- 代码如下：
class CopyBan
{
private:
CopyBan(const CopyBan&); // 声明拷贝构造函数为私有
CopyBan& operator=(const CopyBan&); // 声明拷贝赋值运算符为私有
public:
CopyBan() {} // 默认构造函数
};
【解释说明】
- 设置成私有：如果只声明没有设置成private，用户自己如果在类外定义了，就可以不能禁止拷贝了
- 只声明不定义：不定义是因为该函数根本不会调用，定义了其实也没有什么意义，不写反而还简单，而且如果定义了就不会防止成员函数内部拷贝了。
使用该类时，只需简单地继承它即可：
class MyClass : public CopyBan{
// 类的定义
};【C++11】：C++11扩展delete的用法，delete除了释放new申请的资源外，如果在默认成员函数后跟上=delete，表示让编译器删除掉该默认成员函数。
- 代码如下：
class CopyBan
{
//.....
CopyBan(const CopyBan&) = delete; // 删除拷贝构造函数
CopyBan& operator=(const CopyBan&) = delete; // 删除拷贝赋值运算符
//.....
};
【解释说明】
- 在上面的示例中，我们定义了一个名为 CopyBan 的类。通过将拷贝构造函数和拷贝赋值运算符声明为 delete ，我们禁用了对象的拷贝功能；
- 这样一来，任何试图拷贝 CopyBan 类型对象的操作都会在编译时引发错误。
同样的使用该类时，只需简单地继承它即可：
class MyClass : public CopyBan{
// 类的定义
};- 在这个示例中，MyClass 继承了CopyBan 类。但是，由于基类CopyBan 禁用了拷贝构造函数和赋值运算符函数，所以无法对 MyClass 进行拷贝操作。
【小结】
- 使用这种设计，你可以确保该类的实例不会被拷贝，从而避免不必要的对象复制和可能引发的错误。
（二）设计一个只能在堆上创建对象的类
实现方式：
- 将类的构造函数私有，拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象。
- 提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建。
【C++98】 ：
- 代码如下：
class HeapOnly
{
public:
static HeapOnly* CreateObject()
{
return new HeapOnly();
}
private:
HeapOnly() {} // 私有化默认构造函数
// C++98
// 1.只声明,不实现。因为实现可能会很麻烦，而你本身不需要
// 2.声明成私有
HeapOnly(const HeapOnly&);
};
【C++11】：
- 代码如下：
class HeapOnly
{
public:
static HeapOnly* CreateObject()
{
return new HeapOnly();
}
private:
HeapOnly() {} // 私有化默认构造函数
// C++11
HeapOnly(const HeapOnly&) = delete;
};【解释说明】
- 在 C++11 标准之后，可以使用
= delete来删除复制构造函数，而不仅仅是将其声明为私有； - 这种方式更加清晰明了，使得代码更具可读性和表达性。因此，推荐使用 C++11 及以上版本的标准来实现这样的需求。
这样，你就可以使用下面的代码在堆上创建 HeapOnly 类对象：
HeapOnly* obj = HeapOnly::CreateObject();请确保在使用完对象后手动调用 delete 来释放内存：
delete obj;
【小结】
- 这样设计的类将只能在堆上创建对象，并且无法通过拷贝或赋值的方式创建新对象，从而确保了对象的唯一性和创建方式的约束。
（三）设计一个只能在栈上创建对象的类
实现方法：
- 要设计一个只能在栈上创建对象的类，可以使用私有的析构函数和公有的静态成员函数来实现。
【C++98】 ：
- 代码如下：
class StackOnly
{
public:
static StackOnly CreateObj() {
return StackOnly();
}
private:
StackOnly() {} // 私有化默认构造函数
~StackOnly() {} // 私有化析构函数
};
【解释说明】
- 在上面的示例中，我们将默认构造函数和析构函数私有化。这意味着外部无法直接实例化或销毁 StackOnly 类的对象。
- 为了能够创建对象，我们提供了一个名为 CreateObj 的公有静态成员函数。该函数返回一个 StackOnly 类型的对象。
使用代码示例：
StackOnly obj = StackOnly::CreateObj();
- 这样就确保了 StackOnly 类的对象只能在栈上创建，因为无法直接访问私有的默认构造函数;
- 对象的析构由编译器自动处理(不需要手动调用
delete释放内存)，当对象超出作用域时会自动调用析构函数进行资源的释放。
【C++11】：可以使用删除特殊成员函数以及阻止使用new和delete操作符的方式来实现只能在栈上创建对象的类。
- 代码如下：
class StackOnly
{
public:
StackOnly() = default; // 允许默认构造函数
// 删除拷贝构造函数和赋值运算符函数
StackOnly(const StackOnly&) = delete;
StackOnly& operator=(const StackOnly&) = delete;
// 禁止使用new和delete操作符
void* operator new(size_t) = delete;
void operator delete(void*) = delete;
};使用代码示例：
StackOnly obj1; // 在栈上创建对象
// 下面的代码将导致编译错误，因为拷贝构造函数被删除
// StackOnly obj2 = obj1;
// 下面的代码将导致编译错误，因为赋值运算符函数被删除
// StackOnly obj3;
// obj3 = obj1;
// 下面的代码将导致编译错误，因为使用了删除的new运算符
// StackOnly* ptr = new StackOnly;
// 下面的代码将导致编译错误，因为使用了删除的delete运算符
// delete ptr;【解释说明】
- 这样设计的类将只能在栈上创建对象，并且无法通过拷贝或赋值的方式创建新对象，同时禁止使用
new和delete来分配和释放对象的内存，从而确保了对象的唯一性和创建方式的限制。
除了上述方法之外，还有一种比较奇特的方式，可以用于实现只能在栈上创建对象的类。这种方式是通过定义一个私有化的
operator new和operator delete函数来实现，无需删除构造函数和析构函数。
- 代码如下：
class StackOnly
{
public:
// 在 public 区域声明 operator new 和 operator delete 函数
static void* operator new(size_t size) = delete; // 删除 operator new 函数
static void operator delete(void* ptr) noexcept = delete; // 删除 operator delete 函数
private:
// 私有化所有构造、析构函数，包括默认构造函数
StackOnly() {}
StackOnly(const StackOnly&) {}
~StackOnly() {}
};
【解释说明】
- 在上面的示例中，将构造函数和析构函数都设为了私有的，防止对象在堆上创建或销毁。同时，我们在公有区域声明了一个删除的 operator new 和 operator delete 函数，这些函数用于在堆上分配内存和释放内存。
- 由于默认情况下类的 operator new 和 operator delete 函数都是 public 的，因此我们要重新定义它们。而将其声明为 delete，则完全禁止直接在堆上分配和释放内存，从而避免对象在堆上创建。
使用该类时，只能通过栈上的对象进行操作：
StackOnly obj;
【注意】
- 确保了
StackOnly类的对象只能在栈上创建。但是这种方法需要注意的是，在某些情况下，可能会因为需要使用 operator new 和 operator delete 函数而无法编译通过，因此使用时需要慎重考虑。
（四）设计一个不能被继承的类
实现方法：
- 在使用 C++98 标准时，可以通过将构造函数和析构函数设为私有，并且不提供公共的静态工厂方法来实现一个不能被继承的类。
【C++98】 ：
- 代码如下：
class NonInherit
{
private:
NonInherit() {}
~NonInherit() {}
public:
// 禁止通过静态工厂方法创建对象
static NonInherit* GetInstance() {
return NULL;
}
};实现方法：
- 在C++11以及后续的标准中，你可以在类声明的末尾添加关键字
final，来显式地指示该类是不可被继承的。
【C++11】：
- 代码如下：
class A final
{
// ....
};【解释说明】
- 在上述示例中，我们在类的定义前使用了 final关键字，将 A声明为最终类。这意味着其他类无法从A继承。
- 如果其他类尝试继承 A，编译器将会报错。
例如：
class A final
{
//...
};
class B : public A { // 编译错误
// 类定义
};报错如下：
总结
这些特殊类的设计目的是根据特定的需求和编程场景来确定的；
它们有助于代码的组织、可维护性、可扩展性和重用性。通过合理地设计和使用这些特殊类，可以提高代码的质量、可读性和可靠性。
到此，关于本期特殊类设计便讲解结束了。感谢大家的观看和支持！！！
