目录

1、特殊类的设计

2、设计一个类，不能被拷贝

3、设计一个类，只能在堆上创建对象

4、设计一个类，只能在栈上创建对象

5、设计一个类，不能被继承

6、单例模式

1、饿汉模式

2、懒汉模式

1、特殊类的设计

        在实际应用场景中，会存在一些特殊类的设计，比如：

设计一个只能在堆上创建对象的类，这样的设计可以用于需要动态管理内存，或者需要确保对象生命周期与程序控制流无关的场景中。

设计一个不能被拷贝的类，这样的设计常用于需要禁止对象被复制的场景，例如单例模式、线程池等。

 在实际场景中，还有其他的特殊类设计，下面我们来列举几个。

2、设计一个类，不能被拷贝

如果让一个类不拷贝，只需让该类不能调用拷贝构造函数以及赋值运算符重载即可。

在C++98中，将拷贝构造函数与赋值运算符重载只声明不定义，并且将其访问权限设置为私有即可。

class CopyBan
{
public:
	CopyBan()
	{

	}

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

int main()
{
	CopyBan c;
	//CopyBan s(c);
	//CopyBan s=c;
	return 0;
}

而在C++11中，拓展了delete的用法，delete除了释放new申请的资源外，如果在默认成员函数后跟上=delete，表示让编译器删除掉该默认成员函数。

class CopyBan
{
public:
	CopyBan()
	{
	
	}

	CopyBan(const CopyBan&) = delete;
	CopyBan& operator=(const CopyBan&) = delete;
	//...
};
int main()
{
	CopyBan c;
	//CopyBan s(c);
	//CopyBan s=c;
	return 0;
}

3、设计一个类，只能在堆上创建对象

只能在对上创建对象，那么只能使用new来创建

1、私有化析构函数

这样在栈上创建对象会报错

2、可以使用私有的构造函数和析构函数，并通过静态成员函数返回堆上分配的对象指针。这样可以确保对象只能通过堆上的分配方式创建，而不能在栈上创建。

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

public:
    // 静态成员函数用于返回堆上分配的对象指针
    static HeapOnly* createObject() {
        return new HeapOnly();
    }
};

int main()
{
    HeapOnly* h = HeapOnly::createObject();
	//HeapOnly s;  
	return 0;
}

为防止通过拷贝构造在栈上创建对象，需要禁用拷贝构造和赋值重载。

 // 声明拷贝构造函数和赋值运算符重载为私有，不实现它们
    HeapOnly(const HeapOnly&);
    HeapOnly& operator=(const HeapOnly&);

也可以使用C++11中的delete关键字。

4、设计一个类，只能在栈上创建对象

1、同上将构造函数私有化，然后设计静态方法创建对象返回即可

class StackOnly
{
public:
 static StackOnly CreateObj()
 {
 return StackOnly();
 }
    
    // 禁掉operator new可以把下面用new 调用拷贝构造申请对象给禁掉
 // StackOnly obj = StackOnly::CreateObj();
 // StackOnly* ptr3 = new StackOnly(obj);
 void* operator new(size_t size) = delete;
 void operator delete(void* p) = delete;
private:
 StackOnly()  
 :_a(0)
 {}
private:
 int _a;
};

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

2、在C++11中使用final 关键字

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

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

6、单例模式

单例模式是一种设计模式，用于确保类只有一个实例，并提供一个全局访问点。这在需要全局访问点且只需一个实例的情况下非常有用。

在单例模式中，类通常会提供一个静态成员函数来获取类的唯一实例，并且将构造函数设置为私有，以防止直接实例化类的对象。如果类的实例尚未创建，则静态成员函数会创建一个实例并返回它，否则会返回已存在的实例。

1、饿汉模式

// 饿汉模式
// 优点：简单
// 缺点：可能会导致进程启动慢，且如果有多个单例类对象实例启动顺序不确定。
class Singleton
{
public:
	static Singleton* GetInstance()
	{
		return &m_instance;
	}
private:
	// 构造函数私有
	Singleton() {};

	// C++98 防拷贝
	Singleton(Singleton const&);
	Singleton& operator=(Singleton const&);

	// or

	// C++11
	Singleton(Singleton const&) = delete;
	Singleton& operator=(Singleton const&) = delete;

	static Singleton m_instance;
};
Singleton  Singleton::m_instance;

2、懒汉模式

懒汉模式是单例模式的另一种变体，它在需要时才创建实例，而不是在类加载时就创建。这种方式的优点是节省了内存，因为实例只在需要时才被创建，但需要考虑线程安全性。

#include <mutex>

class Singleton {
private:
    // 静态成员变量，用于保存唯一实例
    static Singleton* instance;

    // 私有构造函数，防止外部实例化对象
    Singleton() {}

    // 互斥锁，用于保证线程安全
    static std::mutex mutex;

public:
    // 静态成员函数，返回类的唯一实例
    static Singleton* getInstance() {
        // 在多线程环境下确保只有一个线程能够创建实例
        std::lock_guard<std::mutex> lock(mutex);
        // 如果实例尚未创建，则创建一个新实例
        if (!instance) {
            instance = new Singleton();
        }
        return instance;
    }
};

// 在类外初始化静态成员变量
Singleton* Singleton::instance = nullptr;
// 初始化互斥锁
std::mutex Singleton::mutex;

在这个实现中，通过互斥锁确保了在多线程环境下的线程安全性。在调用Singleton::getInstance() 时，如果实例尚未创建，则会创建一个新实例并返回，否则会直接返回已存在的实例。