对于类的思维境界提升，没有太大的实际意义，但是锻炼思想。

单例模式

饿汉模式

懒汉模式

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

拷贝只会发生在两个场景中：

拷贝构造函数
赋值运算符重载

因此想要让一个类禁止拷贝，只需让该类不能调用拷贝构造函数以及赋值运算符重载即可。（比如：智能指针里的unique_ptr）

C++98

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

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

原因：

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

C++11

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

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

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

在日常中，我们是可以在栈、静态区、堆都可以创建对象。

class HeapOnly
{
private:
    int _val = 0;
};

int main()
{
    HeapOnly hp1;
    static HeapOnly hp2;
    HeapOnly* ptr = new HeapOnly;
    return 0;
}

实现方式：

将类的析构函数私有，再定义函数手动释放。

原理：
HeapOnly hp1; // 栈
static HeapOnly hp2; // 静态区
由于栈与静态区上的对象出生命域就会自动调用析构函数，而析构函数被我们私有化，所以析构函数调用失败，就会出现报错。
HeapOnly* ptr = new HeapOnly; // 堆
由new的对象，是一个ptr的指针，而指针并不会掉用析构函数，所以并没有问题。但是ptr指向的HeapOnly的对象，是new出来的，是会造成内存泄漏。所以释放资源是必要的，所以需要我们再定义函数手动释放。

#include <iostream>

class HeapOnly
{
public:
    // 写法一
    /*static void Delete(HeapOnly* ptr)
    {
        delete ptr;
    }*/

    // 写法二
    void Delete()
    {
        delete this;
    }
private:
    ~HeapOnly()
    {
        std::cout << "~HeapOnly" << std::endl;
    }
    int _val = 0;
};

int main()
{
    HeapOnly* ptr = new HeapOnly;
    //HeapOnly::Delete(ptr);
    ptr->Delete();
    return 0;
}

第一种写法：

// 写法一
static void Delete(HeapOnly* ptr)
{
    delete ptr;
}

HeapOnly::Delete(ptr);

采用static修饰的成员函数，手动调用进行删除，使用static修饰这样调用的时候看着更舒服。

第二种写法：

// 写法二
void Delete()
{
    delete this;
}

ptr->Delete();

没有采用static修饰，所以调用的时候没有上面一种更好看，但是同时也由于没有使用static修饰，所以可以直接对this（this就是此处的ptr）指针delete，没有必要进行传参。

将类的构造函数私有，拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象。提供一个共有的创建对象的成员函数。

原理：

我们将构造函数进行私有化，就会导致栈、静态区、堆都不能正常的执行，因为都是需要调用构造函数的。
HeapOnly hp1; // 栈
static HeapOnly hp2; // 静态区
HeapOnly* ptr = new HeapOnly; // 堆
于是需要我们提供一个共有的创建对象的成员函数，来单独的实现堆上创建对象。
class HeapOnly
{
public:
    void HeapOnly* CreateObj()
    {
        return new HeapOnly;
    }
private:
    // 构造函数私有
    HeapOnly()
    {}
    int _val = 0;
};

int main()
{
    // 创建的时候就会很尴尬
    return 0;
}
但是，便会有一个尴尬的问题：我们提供的是一个成员函数，我们要调用成员函数，需要先有对象，要有对象又要先调用成员函数。这个时候就需要，采用static修饰的方式。

// 只能在堆上创建对象
class HeapOnly
{
public:
    // 提供一个共有的获取对象的方式，控制对象是new出来的。
    static HeapOnly* CreateObj()
    {
        return new HeapOnly;
    }

 	// 防拷贝：使用HeapOnly copy(*ptr); 这个时候会是在栈上
 	HeapOnly(const HeapOnly& hp) = delete;

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

    int _val = 0;
};

int main()
{
    HeapOnly* ptr = HeapOnly::CreateObj();
    return 0;
}

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

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

原理：

根据上面将构造函数私有化，方法处理。
// 只能在栈上创建对象
class StackOnly
{
public:
	static StackOnly CreateObj()
	{
		StackOnly st;
		return st;
	}

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

private:
	int _val;
};

int main()
{
	StackOnly st1 = StackOnly::CreateObj();
	return 0;
}
但是会出现一个问题，构造不能用，那就调拷贝构造呗。
StackOnly st = StackOnly::CreateObj();
                                                                                           
// 拷贝构造
static StackOnly copy(st);
StackOnly* ptr = new StackOnly(st1);
如果，我们使用同上的防拷贝。
// 只能在栈上创建对象
class StackOnly
{
public:
	static StackOnly CreateObj()
	{
		StackOnly st;
		return st;
	}

	// 防拷贝
	StackOnly(const StackOnly& st) = delete;

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

private:
	int _val;
};

int main()
{
	StackOnly st = StackOnly::CreateObj();
	return 0;
}
执行的时候会发现，是限制住了，堆、静态区的拷贝构造行为。
static StackOnly copy(st);
StackOnly* ptr = new StackOnly(st1);
但是执行会发现，栈上的也不行了。
StackOnly st = StackOnly::CreateObj();
所以并没很好的处理掉，并且这个地方其实并不好处理，因为此处我们所实现的成员函数，其中是局部对象，所以必须使用传值进行返回，不能使用传引用进行返回。
static StackOnly CreateObj()
{
	StackOnly st;
	return st;
}
所以拷贝构造不能进行限制，这样限制只会限制自己。所以这个没有很好的解决方案，唯一的能够改善的就是将new的问题给解决掉。

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

	// 不能防拷贝：会限制住栈上的创建
	//StackOnly(const StackOnly& st) = delete;

    // 限制住使用new
	void* operator new(size_t n) = delete;

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

private:
	int _val;
};

int main()
{
	StackOnly st = StackOnly::CreateObj();
    
    static StackOnly copy(st); // 限制不了，算是一个小缺陷
    //StackOnly* ptr = new StackOnly(st1);
	return 0;
}

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

C++98方式

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

private:
    NonInherit()
    {}
};

C++11方法

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

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

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

设计模式：

设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。

#问：为什么会产生设计模式这样的东西呢？

就像人类历史发展会产生兵法。最开始部落之间打仗时都是人拼人的对砍。后来春秋战国时期，七国之间经常打仗，就发现打仗也是有套路的，后来孙子就总结出了《孙子兵法》。孙子兵法也是类似。

使用设计模式的目的：

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

单例模式

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

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

饿汉模式

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

原理：

为了，保证一个进程中该类只有一个实例化的对象，所以需要将构造函数私有化。
class MemoryPool
{ 
public:

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

    int _val = 0;
};

int main()
{
    return 0;
}
在自己对象里面不能创建自己的对象，但是可以创建自己的指针 / 创建自己的静态的对象。在自己的对象里面不能创建自己的对象，但是可以创建自己的指针 / 创建一个静态的自己的对象。

静态：

因为静态不是属于某个类的成员，而是属于这个类的，属于所有对象的，其不是存在于对象内部，而是存在于静态区的。

class MemoryPool
{
public:

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

	char* _ptr = nullptr;

	static MemoryPool _inst; // 声明
};

// 定义
MemoryPool MemoryPool::_inst;

#问：在类外面还能调用构造吗？
// 定义
MemoryPool MemoryPool::_inst;
可以，因为其作用域来说其是类中的成员（类中有声明），只不过是一个静态成员。静态成员可以用构造函数，虽然是在外面，但是相当于声明与定义分离一样，是一个特例。

指针：

class MemoryPool
{
public:
	static MemoryPool* GetInstance()
	{
		return _pinst;
	}
private:
	// 构造函数私有化
	MemoryPool()
	{}

	char* _ptr = nullptr;

	static MemoryPool* _pinst; // 声明
};

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

使用：

此处以指针版本的举例：一般使用单例的方法就是，不用获取到对象，而是直接调用GetInstance()。就获取到了实例，因为实例只有一个，因为只有一个创建的方式，此时这个对象就是单例。

// 饿汉模式 -- 一开始(main函数之前)就创建出对象
#include <iostream>

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* ptr = MemoryPool::GetInstance()->Alloc(10);
    MemoryPool::GetInstance()->Dealloc(ptr);
    return 0;
}

Note：

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

饿汉模式的特点、优点、缺点：

饿汉模式 -- 一开始（main函数之前）就创建出对象。
优点：简单、没有线程安全问题。
缺点：

1、一个程序中，多个单例，并且有先后创建初始化顺序要求时，饿汉无法控制。比如：程序两个单例类A 和 B，假设要求A先创建初始化，B再创建初始化。

融会贯通的理解：
因为它们都是静态成员，静态成员定义出来谁先初始化，谁后初始化，是不能确定的。尤其是在多个文件（在一个同文件中有些编译器可以根据，谁在前面谁先初始化的原则），将项目放在很多个文件，就做不到了，即：无法控制初始化的顺序。

另外，这种懒汉模式单例，在动静态库中也会出问题，比如所是写在动态库里面的：不排除会出现多线程，也就是说单例对象初始化的时候就有多线程，饿汉又需要在main函数前初始化。这个时候很多东西都没有准备好，创建线程就会出现问题。

2、饿汉单例类，初始化时任务多，会影响程序启动速度。

融会贯通的理解：

就如同我们打开一个程序（游戏），一个程序一直在启动，启动半天才好。饿汉模式是在一开始（main函数之前）就创建出对象，所以如果：饿汉单例类，初始化时任务多，也就导致一直进入不了main函数，于是便会影响程序启动速度（主界面都出不来）。

懒汉模式

第一次使用对象再创建对象。

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

// 懒汉模式：第一次使用对象再创建实例对象
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;


int main()
{
	void* ptr = MemoryPool::GetInstance()->Alloc(10);
	MemoryPool::GetInstance()->Dealloc(ptr);
}

#：new出来没释放的问题（单例对象释放问题）

一般情况下，单例对象不需要释放的。

        因为一般整个程序运行期间都可能会用它。单例对象在进程正常结束后，也会资源释放，并且单例对象不大。

--------------------------

        内存泄漏：是指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。而单例是整个循行期间都在使用，所以并不算内存泄漏，程序结束的时候我们不使用了进行释放，和程序自己释放并没有什么区别。

--------------------------

有些特殊场景需要释放。

        比如单例对象析构时，要进行一些持久化(往文件、数据库写)操作。一个单例为了速度快，一个配置文件。配置文件比如配置了一些路径、IP等，为了快是放在内存当中的。所谓的持久化就是将在内存当中的数据写入磁盘文件、数据库。

因为进程结束会帮我们释放资源，但是并不会帮我们做持久化的操作，只有我们自己来进行析构函数完成。