c++学习(特殊类设计)[30]-Toy模板网

这篇具有很好参考价值的文章主要介绍了c++学习(特殊类设计)[30]。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

只能在堆上创建对象的类

如果你想要确保对象只能在堆上创建，可以通过将析构函数声明为私有，并提供一个静态成员函数来创建对象。这样，类的实例化只能通过调用静态成员函数来完成，而无法直接在栈上创建对象。

以下是一个示例：

class HeapOnlyClass {
private:
    HeapOnlyClass() {} // 私有的构造函数，防止在栈上创建对象
    ~HeapOnlyClass() {} // 私有的析构函数

public:
    static HeapOnlyClass* createInstance() {
        return new HeapOnlyClass();
    }
};

int main() {
    // 无法在栈上创建对象
    // HeapOnlyClass obj;

    // 只能通过静态成员函数创建对象
    HeapOnlyClass* obj = HeapOnlyClass::createInstance();

    // 使用对象...

    delete obj; // 释放堆上的对象

    return 0;
}

在上面的示例中，HeapOnlyClass 类的构造函数和析构函数都被声明为私有。这意味着在类的外部无法直接创建对象或销毁对象。

通过提供一个静态成员函数 createInstance()，我们可以在堆上创建对象。静态成员函数返回一个指向 HeapOnlyClass 对象的指针。在 main() 函数中，我们使用 createInstance() 函数来创建对象，并在使用完对象后通过 delete 关键字释放对象。

这样，我们就可以确保对象只能在堆上创建，而无法在栈上创建。

只能在栈上创建对象的类

如果你想要确保对象只能在栈上创建，可以将类的构造函数声明为私有，并提供一个静态成员函数来创建对象。这样，类的实例化只能通过调用静态成员函数来完成，而无法直接在堆上创建对象。

以下是一个示例：

class StackOnlyClass {
private:
    StackOnlyClass() {} // 私有的构造函数，防止在堆上创建对象

public:
    static StackOnlyClass createInstance() {
        return StackOnlyClass();
    }
};

int main() {
    // 无法在堆上创建对象
    // StackOnlyClass* obj = new StackOnlyClass();

    // 只能通过静态成员函数创建对象
    StackOnlyClass obj = StackOnlyClass::createInstance();

    // 使用对象...

    return 0;
}

在上面的示例中，StackOnlyClass 类的构造函数被声明为私有。这意味着在类的外部无法直接创建对象。

通过提供一个静态成员函数 createInstance()，我们可以在栈上创建对象。静态成员函数返回一个 StackOnlyClass 对象。在 main() 函数中，我们使用 createInstance() 函数来创建对象，并在使用完对象后，对象会自动被销毁。

这样，我们就可以确保对象只能在栈上创建，而无法在堆上创建。

单例模式（一个类之只能创建一个对象）

c++学习(特殊类设计)[30],C++,c++,学习

单例模式可以通过懒汉模式和饿汉模式来实现。下面我将为你解释这两种方式的实现。

懒汉模式：
懒汉模式是指在需要获取实例时才会创建对象。实现懒汉模式的关键是延迟实例化，即在第一次调用获取实例的方法时才创建对象。

class LazySingleton {
private:
    static LazySingleton* instance;

    LazySingleton() {} // 私有构造函数

public:
    static LazySingleton* getInstance() {
        if (instance == nullptr) {
            instance = new LazySingleton();
        }
        return instance;
    }
};

LazySingleton* LazySingleton::instance = nullptr;

在上面的示例中，LazySingleton 类的构造函数被声明为私有，无法直接实例化对象。通过静态成员变量 instance 来保存类的唯一实例，并在 getInstance() 方法中进行延迟实例化。如果 instance 为 nullptr，则创建一个新的 LazySingleton 对象。如果 instance 不为 nullptr，则直接返回现有的实例。

饿汉模式：
饿汉模式是指在类加载时就创建对象，无需延迟实例化。实现饿汉模式的关键是在类定义中直接创建对象，并提供一个静态方法来获取这个实例。

class EagerSingleton {
private:
    static EagerSingleton* instance;

    EagerSingleton() {} // 私有构造函数

public:
    static EagerSingleton* getInstance() {
        return instance;
    }
};

EagerSingleton* EagerSingleton::instance = new EagerSingleton();