目录
特殊类设计
对于类的思维境界提升，没有太大的实际意义，但是锻炼思想。
#：请设计一个类，不能被拷贝。
- 拷贝构造函数
- 赋值运算符重载
因此想要让一个类禁止拷贝，只需让该类不能调用拷贝构造函数以及赋值运算符重载即可。（比如：智能指针里的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;
}
- 将类的析构函数私有，再定义函数手动释放。
原理：
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中构造函数私有化，派生类中调不到基类的构造函数。则无法继承
class NonInherit
{
public:
static NonInherit GetInstance()
{
return NonInherit();
}
private:
NonInherit()
{}
};class A final
{
// ....
};#： 请设计一个类，只能创建一个对象 ( 单例模式 )。
#问：为什么会产生设计模式这样的东西呢？
使用设计模式的目的：为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。 设计模式使代码编写真正工程化；设计模式是软件工程的基石脉络，如同大厦的结构一样。
单例模式
-
饿汉模式
就是说不管你将来用不用，程序启动时就创建一个唯一的实例对象。
原理：
为了，保证一个进程中该类只有一个实例化的对象，所以需要将构造函数私有化。
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等，为了快是放在内存当中的。所谓的持久化就是将在内存当中的数据写入磁盘文件、数据库。
因为进程结束会帮我们释放资源，但是并不会帮我们做持久化的操作，只有我们自己来进行析构函数完成。
补充：
对于我们上面的提供一个显示的调用delete，是可以的，但是上面创建一个内部类的方式是更好的。 是自动的，并且是在main函数结束后一定会做到。
懒汉模式的特点、优点、缺点：
- 懒汉模式：第一次使用对象再创建实例对象。
- 优点：
1、控制顺序。
融会贯通的理解：
比如程序两个单例A和B，要求：A先初始化，B再初始化。我们先利用A调用类的GetInstance，再利用B去调用类的GetInstance。这个时候一定保证了A先初始化B后初始化，这个时候B如果要依赖A，随便用。
2、不影响启动速度。
融会贯通的理解：
因为在main函数运行之前初始化很轻，进程启动无负载。
- 缺点：
1、相对复杂。（线程安全问题）多个线程运行会有线程安全的问题 —— 可能两个线程同时进入导致很多问题……。
2、线程安全问题要处理好。
有趣的理解：
- 饿汉模式：
就是饿了，我不管，只能有我一个（单例），而且我太饿了一开始就要吃（main函数前初始化）。
- 懒汉模式：
就是懒了，我不管，只能有我一个（单例），并且我懒得动需要的时候再说（第一次使用对象再创建）
92
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
