【C++】特殊类设计

【C++】特殊类设计

1、不能被拷贝类

要设计一个类，不能被拷贝，可以采用以下方法：

1. 禁用拷贝构造函数：通过将拷贝构造函数声明为私有或删除，可以阻止类的对象被拷贝。

class NonCopyableClass {
private:
    NonCopyableClass(const NonCopyableClass& other) = delete;

public:
    NonCopyableClass() = default;
    // 其他成员函数和数据成员...
};

在上述代码中，将拷贝构造函数声明为private或使用delete关键字删除拷贝构造函数，从而阻止了类的对象被拷贝。

2. 禁用赋值运算符重载：通过将赋值运算符重载函数声明为私有或删除，可以阻止类的对象进行赋值操作。

class NonCopyableClass {
private:
    NonCopyableClass& operator=(const NonCopyableClass& other) = delete;

public:
    NonCopyableClass() = default;
    // 其他成员函数和数据成员...
};

在上述代码中，将赋值运算符重载函数声明为private或使用delete关键字删除赋值运算符重载函数，从而阻止了类的对象进行赋值操作。

通过以上方式，可以设计一个类，阻止对象的拷贝和赋值操作。这样的设计可以在某些情况下，确保类的对象不能被无意间进行拷贝，避免出现意外的行为和错误的结果。

2、 只能在堆上创建对象类

要设计一个类，只能在堆上创建对象，可以使用私有的构造函数和公有的静态成员函数来实现：

class HeapOnlyClass {
private:
    HeapOnlyClass() {}  // 私有构造函数

public:
    static HeapOnlyClass* createInstance() {
        return new HeapOnlyClass();  // 在堆上创建对象
    }

    // 其他成员函数和数据成员...
};

在上述代码中，私有的构造函数HeapOnlyClass()防止了类的对象在栈上被创建。然后，通过公有的静态成员函数createInstance()来创建类的对象，该函数返回类的指针，并且在堆上动态分配内存来创建对象。

使用这种设计，类的对象只能通过调用静态成员函数createInstance()在堆上创建，并且不能直接在栈上创建对象，从而限制了对象的创建方式。这样可以确保对象的生命周期由程序员显式地管理，避免了对象被不当地创建或销毁。

请注意，在使用这种设计时，需要负责在适当的时候手动释放堆上分配的对象，以避免内存泄漏。可以使用delete关键字来释放堆上的对象：

HeapOnlyClass* obj = HeapOnlyClass::createInstance();
// 使用对象...
delete obj;  // 释放对象的内存

这样，类的对象只能通过createInstance()来创建，并且在不再需要时手动释放内存，从而确保对象的正确生命周期和资源管理。

3、只能在栈上创建对象类

要设计一个类，只能在栈上创建对象，可以使用删除的操作符来实现：

class StackOnlyClass {
public:
    StackOnlyClass() = default;
    ~StackOnlyClass() = default;

    StackOnlyClass(const StackOnlyClass&) = delete;
    StackOnlyClass& operator=(const StackOnlyClass&) = delete;

    // 其他成员函数和数据成员...
};

在上述代码中，我们删除了拷贝构造函数和赋值运算符重载函数，这样就禁止了对象的拷贝和赋值操作。默认的构造函数和析构函数保持不变。

由于拷贝构造函数和赋值运算符重载函数被删除，编译器将禁止在类的对象之间进行拷贝或赋值操作。这意味着只能在栈上创建类的对象，因为在栈上创建对象不需要执行拷贝或赋值操作。

下面是使用该类的示例：

int main() {
    StackOnlyClass obj;  // 在栈上创建对象

    // 使用对象...

    return 0;
}

在上述示例中，我们在main()函数中使用栈上创建的对象obj，没有涉及到拷贝或赋值操作。

通过删除拷贝构造函数和赋值运算符重载函数，可以确保类的对象只能在栈上创建，从而限制了对象的创建方式。这种设计可以防止对象被不当地拷贝或赋值，强制对象的生命周期与其作用域相对应，提高代码的可靠性和安全性。

4、不能被继承类

要设计一个不能被继承的类，可以使用C++11标准引入的final关键字来声明类：

class NonInheritableClass final {
public:
    // 成员函数和数据成员...
};

在上述代码中，我们使用final关键字将类声明为最终类，即不能被其他类继承。这样，任何尝试继承该类的操作都会导致编译错误。

如果有其他类尝试继承NonInheritableClass，编译器将会报错，例如：

class DerivedClass : public NonInheritableClass {
    // ...
};

在上述示例中，DerivedClass试图从NonInheritableClass继承，但由于NonInheritableClass被声明为final，因此会导致编译错误。

通过使用final关键字，我们可以确保类不能被其他类继承，从而限制了类的继承关系。这种设计可以避免类被滥用或被修改，增强了代码的封装性和安全性。注意，final关键字仅适用于类的声明，而不是类的对象实例化过程。

5、只能创建一个对象(单例模式)类

要设计一个类，只能创建一个对象，可以使用单例模式来实现。单例模式确保一个类只有一个实例，并提供一个全局访问点来获取该实例。以下是一个简单的单例模式的实现：

class SingletonClass {
public:
    static SingletonClass& getInstance() {
        static SingletonClass instance;  // 保证只创建一个实例
        return instance;
    }

    // 其他成员函数和数据成员...

private:
    SingletonClass() {}  // 私有构造函数，防止外部创建对象
    ~SingletonClass() {} // 可选的私有析构函数，确保对象无法被删除
    SingletonClass(const SingletonClass&) = delete; // 删除拷贝构造函数
    SingletonClass& operator=(const SingletonClass&) = delete; // 删除赋值运算符重载函数
};

在上述代码中，通过静态成员函数getInstance()来获取类的实例，确保只创建一个实例并返回。静态局部变量保证了实例只会在首次调用getInstance()时创建，并在后续调用时重用。私有的构造函数防止外部代码直接创建对象，而删除拷贝构造函数和赋值运算符重载函数则防止通过拷贝或赋值方式创建新实例。

使用单例模式时，可以通过以下方式获取类的实例：

SingletonClass& instance = SingletonClass::getInstance();

在整个程序的执行过程中，无论在何处调用getInstance()，都将返回同一个实例。

载函数则防止通过拷贝或赋值方式创建新实例。

使用单例模式时，可以通过以下方式获取类的实例：

SingletonClass& instance = SingletonClass::getInstance();