【C++ 学习㊲】- 五种特殊类的设计

一、设计一个禁止拷贝的类

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

C++98/03：


class CopyBan
{
public:
    CopyBan() { }
private:
    CopyBan(const CopyBan& cb);
    CopyBan& operator=(const CopyBan& cb);
};
int main()
{
    CopyBan cb1;
    // CopyBan cb2(cb1);  // error
    // CopyBan cb3;
    // cb3 = cb1;  // error
    return 0;
}

C++11：


class CopyBan
{
public:
    CopyBan() { }
    CopyBan(const CopyBan& cb) = delete;
    CopyBan& operator=(const CopyBan& cb) = delete;
};
int main()
{
    CopyBan cb1;
    // CopyBan cb2(cb1);  // error
    // CopyBan cb3;
    // cb3 = cb1;  // error
    return 0;
}

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

将类的构造函数设置为私有，同时禁止拷贝构造函数的生成，防止通过拷贝构造创建对象；最后提供一个创建堆对象的静态成员函数。


#include 
using namespace std;
 
class HeapOnly
{
public:
	static HeapOnly* Create()
	{
		return new HeapOnly;
	}
private:
	HeapOnly()
	{
		cout << "HeapOnly()" << endl;
	}
 
	HeapOnly(const HeapOnly& ho) = delete;
};
 
int main()
{
	// HeapOnly ho;  // error
	// static HeapOnly sho;  // error
	HeapOnly* pho = HeapOnly::Create();  // HeapOnly()
	// HeapOnly copy(*pho);  // error
	delete pho;
	return 0;
}

将类的析构函数设置为私有，然后提供一个完成 delete 操作的静态成员函数。


#include 
using namespace std;
 
class HeapOnly
{
public:
	void Destroy()
	{
		delete this;
	}
private:
	~HeapOnly()
	{
		cout << "~HeapOnly()" << endl;
	}
};
 
int main()
{
	// HeapOnly ho;  // error
	// static HeapOnly sho;  // error
	HeapOnly* pho = new HeapOnly;
	// HeapOnly copy(*pho);  // error
	pho->Destroy();  // ~HeapOnly()
	return 0;
}

三、设计一个只能在栈区和静态区上创建对象的类

将类的构造函数设置为私有，然后提供一个创建对象的静态成员函数。


#include 
using namespace std;
class StackStaticOnly
{
public:
    static StackStaticOnly CreateObj()
    {
        return StackStaticOnly();
    }
private:
    StackStaticOnly()
    {
        cout << "StackStaticOnly()" << endl;
    }
};
int main()
{
    StackStaticOnly sso = StackStaticOnly::CreateObj();  // StackStaticOnly()
    static StackStaticOnly ssso = StackStaticOnly::CreateObj();  // StackStaticOnly()
    // StackStaticOnly* psso1 = new StackStaticOnly;  // error
    // 注意：该方法无法防止以下的情况发生
    // StackStaticOnly* psso2 = new StackStaticOnly(sso);  // ok
    // 如果禁止拷贝构造函数的生成，会导致 CreateObj 函数发生错误
    return 0;
}

直接禁止 operator new 和 operator delete 的生成。


class StackStaticOnly
{
    void* operator new(size_t size) = delete;
    void operator delete(void* p) = delete;
};
int main()
{
    StackStaticOnly sso;
    static StackStaticOnly ssso;
    // StackStaticOnly* psso1 = new StackStaticOnly;  // error
    // StackStaticOnly* psso2 = new StackStaticOnly(sso);  // error
    return 0;
}

四、设计一个不能继承的类

C++98/03：

将基类的构造函数设置私有，派生类就无法调用基类的构造函数，因此无法继承。


class NonInherit
{
public:
    static NonInherit CreateObj()
    {
        return NonInherit();
    }
private:
    NonInherit() { }
};

C++11：

使用 final 关键字修饰类，表示该类不能被继承。
```
class NonInherit final
{ };
```

五、设计一个只能创建一个对象的类（单例模式）

设计模式（Design Pattern）是一种针对软件设计中经常出现的问题和解决方案的标准化描述。它们可以被视为是经验丰富的软件开发人员在解决类似问题时总结出来的设计思路、原则和指导。设计模式帮助我们以一种可重用的方式来解决特定的设计问题，从而使代码更具灵活性、可维护性和可扩展性。

单例模式：一个类只能创建一个对象。该模式可以保证系统中该类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。比如在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息，这种方式简化了在复杂环境下的配置管理。

单例模式有以下两种实现模式：

饿汉模式：

在程序入口之前就完成了单例对象的初始化。


#include 
using namespace std;
class Singleton
{
public:
    // 提供一个获取单例对象的静态成员函数
    static Singleton& GetInstance()
    {
        return _ss;
    }
private:
    // 将类的构造函数设置为私有
    Singleton() 
    {
        cout << "Singleton()" << endl;
    }
    // 禁止拷贝构造函数的生成
    Singleton(const Singleton& s) = delete;
    static Singleton _ss;  // 注意：静态成员变量属于类，不属于某个具体的对象
};
Singleton Singleton::_ss;  // Singleton()
int main()
{
    cout << &Singleton::GetInstance() << endl;
    cout << &Singleton::GetInstance() << endl;
    // 输出的两个地址是相同的
    // Singleton copy(Singleton::GetInstance());  // error
    return 0;
}

懒汉模式：

如果单例对象构造十分耗时或者占用很多资源，比如加载插件、初始化网络连接、读取文件等等，而该对象在程序运行时又有可能不会用到，那么使用饿汉模式，在程序入口之前就完成单例对象的初始化，会导致程序启动时变得非常缓慢，所以在这种情况下使用懒汉模式（延迟加载）更好。


#include 
using namespace std;
class Singleton
{
public:
    static Singleton& GetInstance()
    {
        if (_pss == nullptr)
        {
            _pss = new Singleton;
        }
        return *_pss;
    }
    // 一般情况下，单例对象是不需要释放的，
    // 特殊场景：
    // 1、中途需要显示释放
    // 2、程序结束时，需要做一些特殊动作，比如持久化
    static void DelInstance()
    {
        if (_pss)
        {
            delete _pss;
            _pss = nullptr;
        }
    }
private:
    Singleton()
    {
        cout << "Singleton()" << endl;
    }
    ~Singleton()
    {
        cout << "~Singleton()" << endl;
    }
    Singleton(const Singleton& s) = delete;
    static Singleton* _pss;
};
Singleton* Singleton::_pss = nullptr;
int main()
{
    cout << &Singleton::GetInstance() << endl;
    cout << &Singleton::GetInstance() << endl;
    // Singleton()
    // 输出的两个地址是相同的
    // Singleton copy(Singleton::GetInstance());  // error
    Singleton::DelInstance();
    // ~Singleton()
    return 0;
}