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

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

C++98
将拷贝构造函数与赋值运算符重载只声明不定义，并且将其访问权限设置为私有即可。
原因：
- 设置成私有：如果只声明没有设置成private，用户自己如果在类外定义了，就可以不能禁止拷贝了。
- 只声明不定义：不定义是因为该函数根本不会调用，定义了其实也没有什么意义，不写反而还简单，而且如果定义了就不会防止成员函数内部拷贝了。
C++11
C++11扩展delete的用法，delete除了释放new申请的资源外，如果在默认成员函数后跟上=delete，表示让编译器删除掉该默认成员函数

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


class HeapOnly
{
public:
	/// 方式一: 调用 HeapOnly::Delete(ptr);
	/*static void Delete(HeapOnly* p) 
	{
		delete p;
	}*/

	/// 方式二: 调用 ptr->Delete()
	void Delete()
	{
		delete this;
	}

private:
	// 析构函数私有
	~HeapOnly()
	{
		cout << "~HeapOnly()" << endl;
	}
private:
	int _a;
};

// 将析构函数私有
// 1. 在栈上创建的对象,一定会调用析构函数,无论拷贝还是赋值构造的对象, 只要在栈上就不可以
// 2. new的对象不会调用析构，需要自己解决，所以不会报错
int main()
{
	//HeapOnly hp1;             // 在栈上
	//static HeapOnly hp2;      // 在静态区

	HeapOnly* ptr = new HeapOnly;  // 在堆上
	//HeapOnly::Delete(ptr);
	ptr->Delete();


	//delete ptr; // 这样写不可以,因为会调用 ptr指向对象的析构函数

	return 0;
}




class HeapOnly
{
public:
	// 提供一个公有的，获取对象的方式，对象控制是new出来的
	static HeapOnly* CreateObj()
	{
		return new HeapOnly;
	}

	// 防拷贝
	HeapOnly(const HeapOnly& hp) = delete;
	HeapOnly& operator=(const HeapOnly& hp) = delete;
private:
	// 构造函数私有
	HeapOnly()
		:_a(0)
	{}
private:
	int _a;
};

// 构造函数私有
// 1. 在栈上，静态区，堆上创建对象都不可以,需要 提供一个公有的，获取对象的方式
// 2. static HeapOnly* CreateObj() 一定要加 static 
//    这样定义 HeapOnly* CreateObj(); 函数需要现有一个 HeapOnly 对象; 因为 函数有一个隐藏的this指针, 需要用到对象的成员
//    但是想要构造一个对象 有需要用到 CreateObj() 这个函数 故 现有蛋还是现有鸡呢 矛盾 不可以
//    加 static 就就不需要用到对象的成员了
// 3. 还有问题是拷贝 HeapOnly copy(*hp3) 任然可以在栈上创建对象, 因为不会调用构造函数 
//    所以 需要将 拷贝和赋值 delete
int main()
{
	// HeapOnly hp1;                 // 在栈上不可以
	// static HeapOnly hp2;          // 在静态区不可以

	// HeapOnly* hp3 = new HeapOnly; // 在堆上不可以
	// delete hp3;

	HeapOnly* hp3 = HeapOnly::CreateObj();
	//HeapOnly copy(*hp3);

	delete hp3;

	return 0;
}

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

// 只能在栈上创建对象
class StackOnly
{
public:
	static StackOnly CreateObj()
	{
		StackOnly st;
		return st;
	}

	// 不能防拷贝
	//StackOnly(const StackOnly& st) = delete;
	//StackOnly& operator=(const StackOnly& st) = delete;
	void* operator new(size_t n) = delete;
private:
	// 构造函数私有
	StackOnly()
		:_a(0)
	{}
private:
	int _a;
};

// 只能在栈上创建对象: 只能构造私有
// 1. 和在堆上创建一样，但是这里不能防止拷贝，因为 局部对象要返回 一定会发生拷贝
// 2. 因为1的原因，这里也不能防止在静态区创建对象，但是可以防止堆上的拷贝 因为new对象时，会调用operator new，可以将其delete

int main()
{
	/*StackOnly st1;
	static StackOnly st2;
	StackOnly* st3 = new StackOnly;*/

	StackOnly st1 = StackOnly::CreateObj(); // 这里一定会发生拷贝

	// 拷贝构造
	static StackOnly copy2(st1); // 不好处理，算是一个小缺陷
	//StackOnly* copy3 = new StackOnly(st1); // 可以处理

	return 0;
}

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

C++98方式：构造函数私有化，派生类中调不到基类的构造函数。则无法继承
C++11方法：final关键字，final修饰类，表示该类不能被继承。

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

设计模式：
设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。为什么会产生设计模式这样的东西呢？就像人类历史发展会产生兵法。最开始部落之间打仗时都是人拼人的对砍。后来春秋战国时期，七国之间经常打仗，就发现打仗也是有套路的，后来孙子就总结出了《孙子兵法》。孙子兵法也是类似

使用设计模式的目的：为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。设计模式使代码编写真正工程化；设计模式是软件工程的基石脉络，如同大厦的结构一样。

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

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

饿汉模式

就是说不管你将来用不用，程序启动时就创建一个唯一的实例对象。

// 饿汉模式 -- 一开始(main函数之前)就创建出对象
// 优点：简单、没有线程安全问题 
// 缺点：
// 1、一个程序中，多个单例，并且有先后创建初始化顺序要求时，饿汉无法控制。
// 比如程序两个单例类A 和 B，假设要求A先创建初始化，B再创建初始化。
// 2、饿汉单例类，初始化时任务多，会影响程序启动速度。

class MemoryPool
{
public:
	static MemoryPool* GetInstance()
	{
		return _pinst;
	}

	void* Alloc(size_t n)
	{
		void* ptr = nullptr;
		// ....
		return ptr;
	}

	void Dealloc(void* ptr)
	{
		// ...
	}

private:
	// 构造函数私有化
	MemoryPool()
	{}

	char* _ptr = nullptr;
	// ...

	static MemoryPool* _pinst; // 声明
};

// 定义
MemoryPool* MemoryPool::_pinst = new MemoryPool; 

int main()
{

	void* ptr1 = MemoryPool::GetInstance()->Alloc(10);
	MemoryPool::GetInstance()->Dealloc(ptr1);
}

懒汉模式

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

// 懒汉模式：第一次使用对象再创建实例对象
// 优点：
// 1、控制顺序。
// 2、不影响启动速度。

// 缺点：
// 1、相对复杂。（线程安全问题）
// 2、线程安全问题要处理好
class MemoryPool
{
public:
	static MemoryPool* GetInstance()
	{
		if (_pinst == nullptr)
		{
			_pinst = new MemoryPool;
		}

		return _pinst;
	}

	void* Alloc(size_t n)
	{
		void* ptr = nullptr;
		// ....
		return ptr;
	}

	void Dealloc(void* ptr)
	{
		// ...
	}

	// 实现一个内嵌垃圾回收类    
	class CGarbo {
	public:
		~CGarbo()
		{
			if (_pinst)
				delete _pinst;
		}
	};

private:
	// 构造函数私有化
	MemoryPool()
	{
		// ....
	}

	char* _ptr = nullptr;
	// ...

	static MemoryPool* _pinst; // 声明
};

// 定义
MemoryPool* MemoryPool::_pinst = nullptr;

// 回收对象，main函数结束后，他会调用析构函数，就会释放单例对象（显示释放也可以，但是没有这个好，这是自动的）
static MemoryPool::CGarbo gc;


// 单例对象释放问题：
// 1、一般情况下，单例对象不需要释放的。因为一般整个程序运行期间都可能会用它。
// 单例对象在进程正常结束后，也会资源释放。
// 2、有些特殊场景需要释放，比如单例对象析构时，要进行一些持久化(往文件、数据库写)操作。
// 

int main()
{

	void* ptr1 = MemoryPool::GetInstance()->Alloc(10);
	MemoryPool::GetInstance()->Dealloc(ptr1);
}

原文链接：https://blog.csdn.net/weixin_54183294/article/details/128186623

特殊类设计

目录