特殊类设计

目录

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

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

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

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

5. 请设计一个类，只能创建一个对象（单例模式）

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

有时候有些地方会有一些特殊的要求，对一些类进行一些特殊的要求，设计，比如一个类不能被拷贝，一个类不能被拷贝，这个需求是非常的常见的，比如说像IO流就是不能被拷贝的。

拷贝构造都是被禁掉的，就算是移动构造的话也只能再类内部进行使用，在外部是不能使用的。IO流底层设计的缓冲区，不允许拷贝的，线程也是不允许拷贝的，

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

• C++98

将拷贝构造函数与赋值运算符重载只声明不定义，并且将其风闻权限设置为私有即可，设置为公有的话别人会在外面实现的。

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

原因：

1、设置成私有：如果只声明没有设置成private，用户自己如果在类外定义了，就可以不能禁止拷贝了

2、只声明不定义：不定义是因为该函数根本不会调用，定义了其实也没什么意义，不写反而还简单，而且如果定义了就不会防止成员函数内部拷贝了。

• C++11

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

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

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

实现方式：

1、将类的构造函数私有，拷贝构造声明或私有，防止别再调用拷贝在栈上生成对象。

2、提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建。

方法1：

#include <iostream>
using namespace std;

class HeapOnly
{
public:
        static HeapOnly* CreateObj()
        {
                return new HeapOnly;
        }
        HeapOnly(const HeapOnly&) = delete;
        HeapOnly& operator=(const HeapOnly&) = delete;
private:
        // 构造函数私有化
        HeapOnly()
        {}
};

int main()
{
        // static HeapOnly hp0; // 静态区创建
        // HeapOnly hp1; // 栈上创建
        // HeapOnly* hp2 = new HeapOnly; // 堆上创建

        HeapOnly* hp3 =  HeapOnly::CreateObj(); // 堆上
        // HeapOnly hp4(*hp3); // 栈上
        
        delete hp3;

        return 0;
}

/*
把路全部堵死，然后提供在堆上创建对象的方法。
然后掉创建对象的方法，可是没有对象啊，这就是先有鸡还是先
有蛋的问题，所以我们可以用static来打破这个循环
*/

// 拷贝构造和赋值重载禁掉，防止拷贝和赋值
// 外面不能用，但是在类里面可以用。

方法2：将析构函数私有化

class HeapOnly
{
public:
        void Destroy()
        {
                delete this; // 析构私有，在类外不可以，在类里面可以
        }
private:
        // 析构函数私有化
        ~HeapOnly(){}
};

int main()
{
         static HeapOnly hp0; // 静态区创建
         HeapOnly hp1; // 栈上创建
         HeapOnly* hp2 = new HeapOnly; // 堆上创建
         //delete hp2;
         hp2->Destroy();
        return 0;
}

// 析构函数私有化hp0和hp1创建不了，因为生命周期结束以后
// 他们要自动调用析构函数，析构函数调不动啊。
// hp2没问题，是指针，只有自定义类型的对象才会自动调用
// 构造和析构，上面的是断前路，这个是断后路
// 当然我们要delete hp2也delete不了，delete是由析构和
// operator delete构成，那么这个时候就要提供静态的Destroy
// 函数，在里面delete，因为私有的在类里面可以调用的
// 这个时候可以考虑布冯拷贝构造，因为析构封了，对象创建不
// 出来

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

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

class StackOnly
{
public:
        static StackOnly CreateObj()
        {
                return StackOnly();
        }
        // 不能封死,否则CreateObj用不了，
        // StackOnly(const StackOnly& s) = delete;
        void* operator new(size_t size) = delete;
        void operator delete(void* p) = delete;
private:
        StackOnly()
                :_a(0)
        {}
private:
        int _a;
};


int main()
{
        //static StackOnly s1; // 静态的
        //StackOnly s2; // 局部的
        //StackOnly* s3 = new StackOnly; // new的

        StackOnly s4 = StackOnly::CreateObj();

        // new调的是构造，那么也可以调拷贝构造
        // 把拷贝构造封了？那CreateObj走的是传值返回
        // 栈上创建的局部对象，只能走传值返回
        // 局部对象走传值返回一定要调用拷贝构造啊，
        // 所以这个地方封拷贝构造是不好封的，
        // 我们可以考虑封operator new和operator delete
        // new由两部分构成，一部分是operator new,另外
        // 一部分才是构造，operator new怎么封呢？
        // operator new默认是全局函数，但是C++固定，如果一个
        // 类重载了专属的operator new的话，它必须得调用专属
        // 的operator new，
        
        // StackOnly* s5 = new StackOnly(s4);

        // delete掉new和delete可以封死上面的，但是封不死下面的

        static StackOnly s6(s4); // 拷贝构造不封的话始终有问题
        StackOnly s7(s4); // 拷贝构造不封的话始终有问题

        return 0;
}

反正这里还是没有封死，拷贝构造不能封，但是不封拷贝构造能调也是有问题的，那么我们可以从C++11的角度解决一下这个问题。我们还是考虑封拷贝构造。

class StackOnly
{
public:
        static StackOnly CreateObj()
        {
                return StackOnly();
        }

        // 提供移动构造
        StackOnly(StackOnly &&s)
        {}
        // 为什么移动构造就可以呢？
        /*
        return匿名对象就是右值，就算是左值，也可以move一下，弄成
        右值以后，哪怕生成中间的临时对象，走移动构造，临时对象再走
        s4也是移动构造，当然编译器优化不会产生临时对象，直接走到s4，
        甚至是直接一步构造，不管编译器优化不优化，这里要么走构造，
        要么走移动构造，不会走拷贝构造。
        */

        StackOnly(const StackOnly& s) = delete;
private:
        StackOnly()
                :_a(0)
        {}
private:
        int _a;
};


int main()
{
        //static StackOnly s1; // 静态的
        //StackOnly s2; // 局部的
        //StackOnly* s3 = new StackOnly; // new的

        StackOnly s4 = StackOnly::CreateObj();

        //StackOnly* s5 = new StackOnly(s4);

        // delete掉new和delete可以封死上面的，但是封不死下面的

        //static StackOnly s6(s4); // 拷贝构造不封的话始终有问题
        //StackOnly s7(s4); // 拷贝构造不封的话始终有问题

        // 就算封死拷贝构造，提供移动构造，还可以这样玩
        static StackOnly s6(move(s4));
        StackOnly* s5 = new StackOnly(move(s6));
        return 0;
}

还是第一种方法更好一点，最起码把new给堵死了。

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

• C++98方式

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

• C++11方法

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

class A final
{
    // ...
};

5. 请设计一个类，只能创建一个对象（单例模式）

设计模式：

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

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

比如迭代器模式、适配器模式、还有现在的单例模式，还有工厂模式、观察者模式、装饰器模式。

单例模式：

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

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

• 饿汉模式

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

// 饿汉模式
// 1、多个饿汉模式的单例，某些对象初始化内容较多(读文件)，初始化程序启动慢
// 因为单例要在main函数开始前创建好,main函数前也没有多线程的概念,要不然还
// 可以并发
// 2、A和B两个饿汉，对象初始化存在依赖关系，要求A先初始化，A再初始化，饿汉
// 无法保证
class InfoMgr
{
public:
        static InfoMgr& GetInstance()
        {
                return _ins;
        }
        void print()
        {
                cout << _ip << endl;
                cout << _port << endl;
                cout << _buffSize << endl;
        }
private:
        InfoMgr(const InfoMgr&) = delete;
        InfoMgr& operator=(const InfoMgr&) = delete;
        InfoMgr()
        {}
private:
        string _ip = "127.0.0.1";
        int _port = 80;
        size_t _buffSize = 1024 * 1024;
        // ...

        // 不是对象中创建自己, 类里面声明
        static InfoMgr _ins; // 静态的在静态区，就是一个全局的静态
};

InfoMgr InfoMgr::_ins; // 类外面定义

int main()
{
        /*InfoMgr info1;
        InfoMgr info2;
        static InfoMgr info3;*/

        InfoMgr::GetInstance().print();
        //InfoMgr copy(InfoMgr::GetInstance()); // 要封拷贝构造
        return 0;
}

• 懒汉模式

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

// 懒汉模式 - 针对饿汉进行的改良的版本

class InfoMgr
{
public:
        static InfoMgr& GetInstance()
        {
                // 第一次调用时创建单例对象
                // 线程安全的风险
                if (_pins == nullptr)
                {
                        _pins = new InfoMgr;
                }
                return *_pins;
        }
        void print()
        {
                cout << _ip << endl;
                cout << _port << endl;
                cout << _buffSize << endl;
        }
        static void DelInstance()
        {
                delete _pins;
                _pins = nullptr;
        }
private:
        InfoMgr(const InfoMgr&) = delete;
        InfoMgr& operator=(const InfoMgr&) = delete;
        InfoMgr()
        {}
private:
        string _ip = "127.0.0.1";
        int _port = 80;
        size_t _buffSize = 1024 * 1024;
        // ...

        static InfoMgr* _pins;
};

InfoMgr* InfoMgr::_pins = nullptr; // 类外面定义

int main()
{
        InfoMgr::GetInstance().print();
        return 0;
}

/*
1、线程安全的风险
2、懒汉模式单例释放，因为是new出来的，所以要手动释放，但是
因为是全局的，程序结束也就释放了，而且只有一份，倒也不影响,
内存怕的是持续不断的内存泄漏
*/

懒汉模式还有一种更简单的方式。

// 懒汉模式还有一种更简单的方式，这种方式再C++11之后比较推荐

class InfoMgr
{
public:
        static InfoMgr& GetInstance()
        {
                // 第一次调用时创建单例对象
                // 局部静态的特点不是再main函数之前就初始化，而是
                // 在第一次调用的时候初始化，局部的静态跟全局的静态
                // 不一样，类里面的静态是全局的静态，main函数之前就
                // 初始化了，这个不是main函数之前就初始化的，不是main
                // 函数之前就初始化的，创建出来就是懒汉,main函数之前就
                // 创建出来的就是饿汉，
                // C++11之后是线程安全的，C++11之前都写的是上面的
                static InfoMgr ins;
                return ins;
        }
        void print()
        {
                cout << _ip << endl;
                cout << _port << endl;
                cout << _buffSize << endl;
        }
private:
        InfoMgr(const InfoMgr&) = delete;
        InfoMgr& operator=(const InfoMgr&) = delete;
        InfoMgr()
        {}
private:
        string _ip = "127.0.0.1";
        int _port = 80;
        size_t _buffSize = 1024 * 1024;
        // ...
};

int main()
{
        // 就算多次调用，但只有一份
        InfoMgr::GetInstance().print();
        InfoMgr::GetInstance().print();

        cout << &InfoMgr::GetInstance() << endl;
        cout << &InfoMgr::GetInstance() << endl;

        return 0;
}

带锁的懒汉模式。

// 懒汉
// 有点: 第一次使用实例对象时，创建对象。进程启动无负载。多个单例
// 实例启动顺序自由控制

// 缺点: 复杂

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

        static Singleton* m_pInstance; // 单例对象指针
        static mutex m_mtx; // 互斥锁
};

Singleton* Singleton::m_pInstance = nullptr;
Singleton::CGarbo Garbo;
mutex Singleton::m_mtx;

int main()
{
        //thread t1([] {cout << &Singleton::GetInstance() << endl; });
        //thread t2([] {cout << &Singleton::GetInstance() << endl; });
        thread t1([] {cout << Singleton::GetInstance() << endl; });
        thread t2([] {cout << Singleton::GetInstance() << endl; });
        t1.join();
        t2.join();

        //cout << &Singleton::GetInstance() << endl;
        //cout << &Singleton::GetInstance() << endl;
        cout << Singleton::GetInstance() << endl;
        cout << Singleton::GetInstance() << endl;

        return 0;
}

/*
单独再设计一个内部类，这个内部类的析构函数去释放这个单例，然后把
这个对象定义成全局对象或者静态对象，main函数结束会调用析构，
它的析构中就会delete Instance，delete Instance会反向火来调到它的
析构，只要程序结束，一定保证会调到这个单例的析构。
你想要一些东西再main函数结束之后自动做，是可以考虑定义一个类，然后
用这个类设计一个全局对象，全局对象出了作用域就会调用析构函数，那么
你就可以再这个析构函数中干你相干的事情
*/