企业官网建设流程全解析

class CopyBan { // ... private: CopyBan(const CopyBan&); CopyBan& operator=(const CopyBan&); /*c++11:可以直接删除这两个函数 CopyBan(const CopyBan&)=delete; CopyBan& operator=(const CopyBan&)=delete; */ // ... };

1. 将拷贝构造函数和赋值运算符重载只声明而不定义。这样类不会自动生成默认的拷贝构造函数和赋值运算符重载，且当前只是两个函数的声明，没有定义也无法调用。因此如果用户在执行流中拷贝对象就会在链接时因为找不到函数定义而报错。
2. 将拷贝构造函数和赋值运算符重载声明为私有。这是因为在public限制符下，如果用户在类外定义这两个函数，就可以使用拷贝构造了，但是一但声明为私有，就算定义了在类外也无法调用。把这两个函数声明为私有还有一个好处，那就是调用拷贝构造在语法检查时就能爆出错误而不用等到编译链接时。
3. 这种方式下，仍然无法完全禁止拷贝，如下：

class CopyBan { CopyBan* getCopy() { return new CopyBan(*this);//调用了拷贝构造 } private: CopyBan(const CopyBan&); CopyBan& operator=(const CopyBan&); }; CopyBan::CopyBan(const CopyBan&) { //拷贝构造的实现 }

不过，使用c++11新引入特性delete删除相应拷贝函数，无论如何也无法调用了，解决了这个问题。

只能在堆上创建对象的类

本质就是要让我们控制创建对象的方式，而创建对象与构造函数有关（包括拷贝构造）。

class HeapOnly { public: static HeapOnly* CreateObject() { return new HeapOnly; } private: HeapOnly() {} HeapOnly(const HeapOnly&)； /*c++11: private: HeapOnly() {} HeapOnly(const HeapOnly&) = delete; */ };

1. 将构造函数私有化。阻止类外使用构造函数定义对象。
2. 将拷贝构造函数只声明而不定义。这样类不会自动生成默认的拷贝构造函数；且当前只是这个函数的声明，没有定义也无法调用。因此类内外都无法调用拷贝构造函数，所以不会有拷贝堆上的对象从而在栈上创建对象的可能。
3. 将拷贝构造函数声明为私有。这是因为在public限制符下：如果用户在类外定义这个函数，就可以使用拷贝构造了，但是一但声明为私有，就算定义了在类外也无法调用。
4. 这种方式下，仍然可以在可以在栈上创建对象：

class HeapOnly { public: static HeapOnly* CreateObject() { return new HeapOnly; } HeapOnly func() { HeapOnly x;//在栈上定义对象 return x; } private: HeapOnly() {} HeapOnly(const HeapOnly&); /*c++11: private: HeapOnly() {} HeapOnly(const HeapOnly&) = delete; */ }; HeapOnly::HeapOnly(const HeapOnly& x) { //拷贝函数 }

不过，不过，使用c++11新引入特性delete删除相应拷贝构造函数，无论如何也无法调用了，解决了这个问题。

只在栈上创建对象的类

本质就也是要让我们控制创建对象的方式，而创建对象与构造函数有关（包括拷贝构造）。

class StackOnly { public: StackOnly() :_a(0) {} void* operator new(size_t size) = delete; void operator delete(void* p) = delete; /* private: void* operator new(size_t size); void operator delete(void* p); 也可以这样定义来防止new和delete，但是也会出现在“禁止拷贝的类”中出现的问题：类外 定义operator new和operator delete，在类内定义成员函数调用它们。 */ private: int _a; };

1. 将构造函数不能私有化。让用户可以在类外定义栈对象。
2. 将operator new和operator delete禁用掉。直接使类内以及全局的new重载无法调用，也就无法直接在堆上创建对象了。

为什么能禁用？

虽然operator new不是默认成员函数，但如果你在类中声明了它（即使是= delete），编译器会优先查找类专属版本，而不会再使用全局版本。也就是说，在上面的例子中，全局的new和delete也被类内的声明给隐藏了，调用不到而类中的new和delete被删除了，也掉用不了。所以对于该类来说，无法new。

不能被继承的类

//辅助虚基类 class Base { private: Base(){} Base(const Base & x){} friend class NonInherit; }; //不可被继承的类 class NonInherit: virtual public Base { public: NonInherit() {} }; /* c++11 //不可被继承的类 class NonInherit final { public: NonInherit() {} }; */

c++11之前的无法继承的类的设计方式是依赖于虚继承的规则，如果一个类继承目标类，那么Base肯定是这个类的虚基类，而类的构造函数一定要调用其虚基类的构造函数（因为虚继承本身就是为了防止两个父类重复调用虚基类构造函数，所以让子类调用虚基类构造函数），但是我们把虚基类的构造函数私有了，因此该类无法继承目标类。为了不影响目标类本身构造，把目标类声明为Base类的友元类即可。（还有一种方法是私有目标类的构造函数，然后对外提供创建对象的接口）

c++11以后，使用final关键字即可防止继承。

只能创建一个对象的类（单例模式）

需要禁止一切类外的构造，包括拷贝构造。

饿汉模式

// 饿汉模式 // 优点：简单 // 缺点：可能会导致进程启动慢，且如果有多个单例类对象实例启动顺序不确定。 class Singleton { public: static Singleton* GetInstance() { return &m_instance; } private: // 构造函数私有 Singleton() {}; // 防拷贝 Singleton(Singleton const&); Singleton& operator=(Singleton const&);//其实没必要禁止赋值。 /* C++11 Singleton(Singleton const&) = delete; Singleton& operator=(Singleton const&) = delete; */ static Singleton m_instance; }; Singleton Singleton::m_instance{};//直接定义出实例来

把m_instance定义为static变量原因有二：

1. 获取唯一实例的接口必须是静态函数，而静态函数只能访问静态变量
2. 将m_instance定义为static可以保证它只有一份

饿汉模式优点：

• 线程安全
• 每次获取实例的时候不用判断加锁，也不会中途创建对象，效率高一点

饿汉模式缺点：

• 在一个程序中如果有多个单例，并且有先后创建初始化顺序要求时，饿汉无法控制。例如，程序两个单例类A 和 B，假设要求A先创建初始化，B再创建初始化。然而静态成员谁先初始化是不确定的，尤其是多个文件 （单个文件可能是按顺序的）。

• 增加程序启动时间。由于饿汉模式在类加载时就创建实例，所以它会增加程序启动时间。

• 可能浪费内存空间。如果最终没有使用该对象，则会浪费内存空间。

懒汉模式

需要的时候再创建实例。

// 懒汉 // 优点：第一次使用实例对象时，创建对象。进程启动无负载。多个单例实例启动顺序自由控制。 // 缺点：复杂 #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&);//其实没必要禁止赋值。 /*C++11 Singleton(Singleton const&) = delete; Singleton& operator=(Singleton const&) = delete; */ static Singleton* m_pInstance; // 单例对象指针，因为是延迟加载，不能直接定义变量了 static mutex m_mtx;//互斥锁 }; //定义static成员 Singleton* Singleton::m_pInstance = nullptr; Singleton::CGarbo Garbo{}; mutex Singleton::m_mtx{};