序言

特殊类设计是指在面向对象编程中，根据特定需求或情况，创建具备特殊功能或属性的类。特殊类设计旨在解决特定问题或满足特殊需求，使代码更加灵活和可扩展。

（一）设计一个不能被拷贝的类

拷贝只会放生在两个场景中：拷贝构造函数以及赋值运算符重载，因此想要让一个类禁止拷贝，只需让该类不能调用拷贝构造函数以及赋值运算符重载即可。

接下来，我们分别从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 { // 编译错误
	// 类定义
};

报错如下：

总结

这些特殊类的设计目的是根据特定的需求和编程场景来确定的；

它们有助于代码的组织、可维护性、可扩展性和重用性。通过合理地设计和使用这些特殊类，可以提高代码的质量、可读性和可靠性。

到此，关于本期特殊类设计便讲解结束了。感谢大家的观看和支持！！！

【C++】—— 特殊类设计

序言

（一）设计一个不能被拷贝的类

（二）设计一个只能在堆上创建对象的类

（三）设计一个只能在栈上创建对象的类

（四）设计一个不能被继承的类

总结

猜你喜欢