我与c++的爱恋：特殊类设计

​

​

🔥个人主页：guoguoqiang. 🔥专栏：我与C++的爱恋

1.请设计一个类，不能被拷贝

拷贝只会放生在两个场景中：拷贝构造函数以及赋值运算符重载，因此想要让一个类禁止拷贝，
只需让该类不能调用拷贝构造函数以及赋值运算符重载即可。
C++98
将拷贝构造函数与赋值运算符重载只声明不定义，并且将其访问权限设置为私有即可。​

class CopyBan
{
// ...
private:
    CopyBan(const CopyBan&);
    CopyBan& operator=(const CopyBan&);
    //...
};

​原因：

1. 设置成私有：如果只声明没有设置成private，用户自己如果在类外定义了，就可以不
   能禁止拷贝了
2. 只声明不定义：不定义是因为该函数根本不会调用，定义了其实也没有什么意义，不写
   反而还简单，而且如果定义了就不会防止成员函数内部拷贝了。
   C++11 中
   C++11扩展delete的用法，delete除了释放new申请的资源外，如果在默认成员函数后跟上 =delete，表示让编译器删除掉该默认成员函数。

class CopyBan
{
// ...
    CopyBan(const CopyBan&)=delete;
    CopyBan& operator=(const CopyBan&)=delete;
    //...
};

2. 请设计一个类，只能在堆上创建对象

实现方式：

1. 将类的构造函数私有，拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象。
2. 提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建

#include <iostream>
 
class HeapOnly {
private:
    // 私有构造函数，防止在栈上创建对象
    HeapOnly() {}
 
public:
    // 阻止拷贝构造函数和赋值操作符，防止栈上对象的拷贝和赋值
    HeapOnly(const HeapOnly&) = delete;
    HeapOnly& operator=(const HeapOnly&) = delete;
 
    // 提供一个公有的静态方法用于创建对象
    static HeapOnly* CreateInstance() {
        return new HeapOnly();
    }
 
    // 提供一个公有的静态方法用于销毁对象
    static void DeleteInstance(HeapOnly* instance) {
        delete instance;
    }
 
    // 其他公有成员函数...
    void DoSomething() {
        std::cout << "Doing something..." << std::endl;
    }
 
    // 公有析构函数，确保对象可以正常销毁
    ~HeapOnly() {
        std::cout << "HeapOnly object destroyed" << std::endl;
    }
};
 
int main() {
    // 在栈上创建对象是不允许的，下面的代码会导致编译错误
    // HeapOnly stackOnly;
 
    // 在堆上创建对象
    HeapOnly* heapOnly = HeapOnly::CreateInstance();
    heapOnly->DoSomething();
 
    // 销毁堆上的对象
    HeapOnly::DeleteInstance(heapOnly);
 
    return 0;
}

3.请设计一个类，只能在栈上创建对象

在C++中，要设计一个类使其只能在栈上创建对象，我们需要做以下几件事情：

将类的构造函数设为公有，这样就可以在栈上创建对象。

将析构函数设为公有，以确保对象可以在栈上正常销毁。

将拷贝构造函数和赋值操作符设为私有或删除，以防止通过这些操作在堆上创建对象。
还需将operator new以及operator new[]封死

#include <iostream>
 
class StackOnly {
private:
    // 防止在堆上通过 new 创建对象
    void* operator new(size_t size) = delete;
    void* operator new[](size_t size) = delete;
 
    // 防止拷贝构造和赋值操作 防止在堆上创建对象
    StackOnly(const StackOnly&) = delete;
    StackOnly& operator=(const StackOnly&) = delete;
 
public:
    // 公有的构造函数，允许在栈上创建对象
    StackOnly() {
        std::cout << "StackOnly object created on the stack." << std::endl;
    }
 
    // 公有的析构函数，确保对象可以正常销毁
    ~StackOnly() {
        std::cout << "StackOnly object destroyed." << std::endl;
    }
};

4.请设计一个类，不能被继承

C++98方式

// C++98中构造函数私有化，派生类中调不到基类的构造函数。则无法继承 
class NonInherit
{
public:
    static NonInherit GetInstance()
    {
        return NonInherit();
    }
private:
    NonInherit()
		{}
};

C++11方法

final关键字，final修饰类，表示该类不能被继承

class A  final
{
//....
};

5. 请设计一个类，只能创建一个对象(单例模式)

设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。
单例模式：
一个类只能创建一个对象，即单例模式，该模式可以保证系统中该类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。
单例模式可以分为两种

1. 饿汉模式
   就是说不管你将来用不用，程序启动时就创建一个唯一的实例对象。
   饿汉模式
   优点：简单
   缺点：可能会导致进程启动慢，且如果有多个单例类对象实例启动顺序不确定。

#include <iostream>
 
class Singleton {
private:
    // 私有静态成员变量，在程序启动时初始化
    static Singleton instance;
 
    // 私有构造函数，防止外部创建实例
    Singleton() {}
 
    // 防止复制构造函数和赋值操作
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
 
public:
    // 提供一个公共的静态方法来获取单例实例
    static Singleton& getInstance() {
        return instance;
    }
 
    // 示例方法
    void doSomething() {
        std::cout << "Doing something..." << std::endl;
    }
};
 
// 在程序启动时初始化静态成员变量
Singleton Singleton::instance;
 
int main() {
    // 获取单例实例并调用方法
    Singleton& singleton = Singleton::getInstance();
    singleton.doSomething();
 
    return 0;
}

如果这个单例对象在多线程高并发环境下频繁使用，性能要求较高，那么显然使用饿汉模式来避免资源竞争，提高响应速度更好。
2. 懒汉模式

优点：第一次使用实例对象时，创建对象。进程启动无负载。多个单例实例启动顺序自由控制。
缺点：复杂
懒汉模式（Lazy Initialization）是单例模式的一种实现方式，它将对象的实例化推迟到第一次使用时，而不是在类加载时。这样可以节省资源，特别是当单例对象初始化成本较高，或者不确定是否真的需要使用该对象时。

#include <iostream>
#include <mutex>
 
class Singleton {
private:
    // e用于指向单例对象的实例
    static Singleton* instance;
    static std::mutex mutex; // 用于线程同步
 
    // 私有构造函数，防止外部创建实例
    Singleton() {}
 
    // 防止复制构造函数和赋值操作
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
 
public:
    // 提供一个公共的静态方法来获取单例实例
    static Singleton* getInstance() {
        if (instance == nullptr) {
            std::lock_guard<std::mutex> lock(mutex); // 加锁
            if (instance == nullptr) { // 再次检查，以防止多个线程同时通过第一次检查
                instance = new Singleton();
            }
        }
        return instance;
    }
 
    // 示例方法
    void doSomething() {
        std::cout << "Doing something..." << std::endl;
    }
 
    // 提供一个公共的静态方法来释放单例实例
    static void releaseInstance() {
        std::lock_guard<std::mutex> lock(mutex);
        delete instance;
        instance = nullptr;
    }
};
 
// 初始化静态成员变量
Singleton* Singleton::instance = nullptr;
std::mutex Singleton::mutex;
 
int main() {
    // 获取单例实例并调用方法
    Singleton* singleton = Singleton::getInstance();
    singleton->doSomething();
 
    // 释放单例实例
    Singleton::releaseInstance();
 
    return 0;
}