【C++】特殊类设计

0. 设计一个类，不能实例化出对象

C++98写法

• 将类的构造函数声明为private，只能通过调用一个静态成员函数（通常称为create或getInstance等）来获取类的实例。

// C++98
class NoInstance98 
{
private:
    NoInstance98() {}

public:
    static NoInstance98* create() 
    {
        return new NoInstance98();
    }
};

int main()
{
    // C++98
    auto obj98 = NoInstance98::create();
    delete obj98;
    return 0;
}

C++11写法

• 在C++11及以后的版本中，可以使用纯虚函数（pure virtual function）来使类成为抽象类，从而无法被实例化。纯虚函数可以通过在声明时使用= 0来标记。

// C++11
class NoInstance11 
{
public:
    virtual void doSomething() = 0;
};

class Derived : public NoInstance11 
{
public:
    void doSomething() override {}
};

int main() 
{
    // C++11
	NoInstance11 obj11;  // 报错，无法直接实例化抽象类
    Derived objDerived;
    objDerived.doSomething();
	
    return 0;
}

---

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

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

C++98写法

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

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

• 如果尝试调用，会造成编译错误：

#include <iostream>
#include <map>
#include <string>
#include <utility>
using namespace std;

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


int main() 
{
    CopyBan obj1;
    // 尝试复制构造
    CopyBan obj2 = obj1;  // 编译错误:"CopyBan::CopyBan(const CopyBan &)" 不可访问

    // 尝试赋值
    CopyBan obj3;
    obj3 = obj1;  // 编译错误:"CopyBan &CopyBan::operator=(const CopyBan &)" 不可访问	
	
    return 0;
}

[!reasons] 两个原因

1. 设置成私有的原因：如果只声明没有设置成private，用户自己如果在类外定义了，就可以不能禁止拷贝了
2. 只声明不定义的原因：不定义是因为该函数根本不会调用，定义了其实也没有什么意义，不写反而还简单，而且如果定义了就不会防止成员函数内部拷贝了。

C++11写法

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

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

默认构造函数私有化或删除的意义

上面讲了拷贝构造函数和赋值运算符重载的私有化或删除来避免对象拷贝和赋值，那么将默认构造函数私有化或删除的意义是什么呢？

在C++中，私有化默认无参数的构造函数的主要目的是限制对象的默认实例化。当一个类的构造函数被私有化，意味着外部代码无法直接调用该构造函数创建类的对象。这样做的一些常见目的包括：

1. 单例模式（Singleton Pattern）： 通过私有化构造函数，可以确保一个类的实例只能在类内部被创建，从而实现单例模式。单例模式保证一个类只有一个实例，并提供全局访问点。

class Singleton 
{
private:
	Singleton() {} // 私有构造函数
public:
	static Singleton& getInstance() 
	{
		static Singleton instance; // 只有在类内部可以调用构造函数
		return instance;
	}
};

2. 工厂模式（Factory Pattern）： 通过私有化构造函数，可以强制使用类内的工厂方法来创建对象，从而对对象的创建过程进行更严格的控制。

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

public:
	static MyClass createInstance() 
	{
		return MyClass(); // 可以在工厂方法中调用私有构造函数
	}
};

3. 防止对象创建和初始化的滥用： 有时候，类的默认构造函数可能执行一些特殊的初始化操作，或者需要在创建对象时进行一些额外的逻辑。私有化构造函数可以防止外部代码滥用默认构造函数，确保对象在被创建时经过类内部的逻辑。

---

私有化默认无参数的构造函数是一种对类的实例化过程进行控制的手段，用于确保对象的创建和初始化按照类设计者的意图进行。

---

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

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

class HeapOnly
{
public:
	static HeapOnly* CreateObject()
	{
		return new HeapOnly; //在HeapOnly的类作用域里可以调到private的构造函数
	}
private:
	HeapOnly() {}
	
	// C++98
	//  1.只声明,不实现。因为实现可能会很麻烦，而你本身不需要
	//  2.声明成私有
	HeapOnly(const HeapOnly&);
	
	// C++11
	HeapOnly(const HeapOnly&) = delete;
};

int main()
{
	HeapOnly* hp = new HeapOnly; // 编译错误，因为new创建对象也要调用构造函数的，但是你已经私有化构造函数了
	return 0;
}

---

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

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

但是这里就不能禁用拷贝构造了，因为在返回的时候肯定是返回一个局部对象，所以 CreateObject 只能传值返回，但是只要是传值返回就肯定是要拷贝构造，那么如果把拷贝构造禁用了，那么返回的时候就会有问题

class StackOnly
{
public:
	static StackOnly CreateObject()
	{
		return StackOnly();
	}
private:
	StackOnly()
	{}
};

方法二：屏蔽new和delete

class StackOnly
{
public:
	StackOnly() {}
private:
	void* operator new(size_t size);
	void operator delete(void* p);
};
 
int main()
{
	StackOnly so;
	StackOnly* p = new StackOnly;
	 
	static StackOnly sso;
	return 0;
}

也可以用 C++11 的 = delete 去实现

void* operator new(size_t size) = delete;
void operator delete(void* p) = delete;

---

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

C++98写法

1. C++98中构造函数私有化，派生类中调不到基类的构造函数。则无法继承
2. 无法继承的原因是父类私有成员在子类类作用域中不可见

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

C++11写法

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

class A final
{
	// ...
};

5. 设计一个类，只能实例化一个对象（单例模式）

在讲单例模式之前，先讲讲什么是类的设计模式：

1. 设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结
2. 为什么会产生设计模式这样的东西呢？就像人类历史发展会产生兵法。最开始部落之间打仗时都是人拼人的对砍。后来春秋战国时期，七国之间经常打仗，就发现打仗也是有套路的，后来孙子就总结出了《孙子兵法》
3. 使用设计模式的目的：为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。 设计模式使代码编写真正工程化；设计模式是软件工程的基石脉络，如同大厦的结构一样
4. 设计模式分为三大类：创建型模式、结构型模式、行为型模式
   • 创建型模式(5种)：工厂方法、抽象工厂方法、单例模式、建造者模式、原型模式
   • 结构型模式(8种)：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式
   • 行为型模式(13种)：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式

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

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 = new Singleton; 
 
int main()
{
	cout << Singleton::GetInstance() << endl;
	cout << Singleton::GetInstance() << endl;
	cout << Singleton::GetInstance() << endl;
	return 0;
}

• 也可以在类中直接存放静态对象：

class Singleton
{
public:
	static Singleton* GetInstance()
	{
		return &m_instance;
	}
	
	void Add(const string& key, const string& value)
	{
		_dict[key] = value;
	}
	
	void Print()
	{
		for (auto& kv : _dict)
		{
			cout << kv.first << ":" << kv.second << endl;
		}
		cout << endl;
	}
	
private:
	// 构造函数私有
	Singleton()
	{};
	
	// C++11写法
	Singleton(Singleton const&) = delete;
	Singleton& operator=(Singleton const&) = delete;
	
	map<string, string> _dict;
	int _n = 0;
	
	static Singleton m_instance;
};

// 静态成员变量必须在类外进行定义。
// 这是因为静态成员变量不属于任何类的对象或实例，
// 它们是类的一部分。在类外定义静态成员变量可以为其分配内存。
// 如果不在类外定义，编译器就不会为其分配内存，从而导致链接错误。
Singleton Singleton::m_instance;

int main()
{
	Singleton::GetInstance()->Add("hello", "你好");
	Singleton::GetInstance()->Add("sort", "排序");
	Singleton::GetInstance()->Add("patience", "耐心");
	Singleton::GetInstance()->Print();
	cout << (void*)Singleton::GetInstance() << endl;
	cout << (void*)Singleton::GetInstance() << endl;
	cout << (void*)Singleton::GetInstance() << endl;
	return 0;
}

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

1. 饿汉单例模式优点：
   • 保证全局（整个进程）只有唯一实例对象
   • 饿汉模式：一开始就创建对象，特别简单
2. 饿汉单列模式缺点：
   • 多个单例对象A,B,C假设要求他们之间有依赖关系：依次创建,就无法达到，无法保证顺序
   • 可能会导致程序启动很慢

2. 懒汉单例模式（待续）

// 懒汉
// 优点：第一次使用实例对象时，创建对象。进程启动无负载。多个单例实例启动顺序自由控制。
// 缺点：复杂
#include <iostream>
#include <mutex>
#include <thread>
using namespace std;

class Singleton
{
public:
	static Singleton* GetInstance()
	{
		// 注意这里一定要使用Double-Check的方式加锁，才能保证效率和线程安全
		if (nullptr == m_pInstance)
		{
			m_mtx.lock();
			if (nullptr == m_pInstance)
			{
				m_pInstance = new Singleton();
			}
			m_mtx.unlock();
		}
		return m_pInstance;
	}
	// 实现一个内嵌垃圾回收类
	class CGarbo
	{
	public:
		~CGarbo()
		{
			if (Singleton::m_pInstance)
				delete Singleton::m_pInstance;
		}
	};
	// 定义一个静态成员变量，程序结束时，系统会自动调用它的析构函数从而释放单例对象
	static CGarbo Garbo;
private:
	// 构造函数私有
	Singleton() {};
	// 防拷贝
	Singleton(Singleton const&);
	Singleton& operator=(Singleton const&);
	static Singleton* m_pInstance; // 单例对象指针
	static mutex m_mtx; //互斥锁
};
Singleton* Singleton::m_pInstance = nullptr;
Singleton::CGarbo Garbo;
mutex Singleton::m_mtx;
void func(int n)
{
	cout << Singleton::GetInstance() << endl;
}

// 多线程环境下才能演示上面GetInstance()加锁和不加锁的区别
int main()
{
	thread t1(func, 10);
	thread t2(func, 10);
	t1.join();
	t2.join();
	cout << Singleton::GetInstance() << endl;
	cout << Singleton::GetInstance() << endl;
}