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

目录

单例模式

饿汉模式

懒汉模式

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

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

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

C++98

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

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

原因：

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

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;
}

#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);

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

ptr->Delete();

// 只能在堆上创建对象
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;
	}

	// 不能防拷贝：会限制住栈上的创建
	//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中构造函数私有化，派生类中调不到基类的构造函数。则无法继承
class NonInherit
{
public:
    static NonInherit GetInstance()
    {
        return NonInherit();
    }

private:
    NonInherit()
    {}
};

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

静态： 

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

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等，为了快是放在内存当中的。所谓的持久化就是将在内存当中的数据写入磁盘文件、数据库。

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

补充：

        对于我们上面的提供一个显示的调用delete，是可以的，但是上面创建一个内部类的方式是更好的。 是自动的，并且是在main函数结束后一定会做到。

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

• 懒汉模式：第一次使用对象再创建实例对象。
• 优点：

        1、控制顺序。

融会贯通的理解：

        比如程序两个单例A和B，要求：A先初始化，B再初始化。我们先利用A调用类的GetInstance，再利用B去调用类的GetInstance。这个时候一定保证了A先初始化B后初始化，这个时候B如果要依赖A，随便用。

        2、不影响启动速度。

融会贯通的理解：

        因为在main函数运行之前初始化很轻，进程启动无负载。

• 缺点：

        1、相对复杂。（线程安全问题）多个线程运行会有线程安全的问题 —— 可能两个线程同时进入导致很多问题……。

        2、线程安全问题要处理好。

有趣的理解：

• 饿汉模式：

        就是饿了，我不管，只能有我一个（单例），而且我太饿了一开始就要吃（main函数前初始化）。

• 懒汉模式：

         就是懒了，我不管，只能有我一个（单例），并且我懒得动需要的时候再说（第一次使用对象再创建）