【C++】22.单例模式+类型转换

1.单例模式

1°定义

之前已经学过一些设计模式

迭代器模式 -- 基于面向对象三大特性之一的 封装设计出来的 用一个迭代器类封装以后

不暴露容器结构的情况下 统一的方式访问修改容器中的数据

适配器模式 -- 体现的是一种复用

还有一些常见的设计模式如:工厂模式 装饰器模式 观察者模式 单例模式...

单例模式:一个类只能在全局(进程中)只有一个实例对象

什么场景下会使用?

比如一个进程中有一个内存池 进程中的多线程需要内存都要到这个内存池中取 那么这个内存池的类就可以设计单例模式

类的名称是随着你的场景给的 比如你的是内存池 那么你就定义成MemoryPool

2°懒汉模式

懒汉模式--第一次获取对象时 再创建对象

#include <iostream>
#include <thread>
#include <vector>
#include <Windows.h>
#include <mutex>
using namespace std;

namespace Lazy_Man
{
    //懒汉模式--第一次获取对象时 再创建对象
    class Singleton
    {
    public:
        static Singleton* GetInstance()
        {
            //Sleep(1000);//增加没加锁时出现线程不安全的条件(2个以上线程同时过了判断条件)
            //如果有两个线程同时new 最后就不是只有一个对象了
            //加锁解决
            //_mtx.lock();
            if (_pinst == nullptr)//后一波线程来的时候就直接返回了
            {
                unique_lock<mutex> lock(_mtx);
                //出作用域后解锁 但后面还有代码不想保护 添加{}局部域 
                //加锁只用保护第一次 需要优化
                //只要_pinst已经指向了new出来的实例对象 就不需要加锁了
                //可以分析出现在的代码 存在优化空间
                //双检查即可
                if (_pinst == nullptr)
                {
                    _pinst = new Singleton;
                }
            }
            //_mtx.unlock();

            //第一次给一个值
            //后面每次获取的对象就都是一样的
            return _pinst;
        }

        static void DelInstance()
        {
            unique_lock<mutex> lock(_mtx);
            delete _pinst;
            _pinst = nullptr;
        }

    private:
        Singleton()
        {}

        Singleton(const Singleton& s) = delete;

        static Singleton* _pinst;//静态的 每次过来都会是第一次的对象
        static mutex _mtx;
    };

    //1.如果要手动释放单例对象 可以调用DelInstance
    //2.如果需要程序结束时 正常释放单例对象 可以加入下面的设计
    class GC
    {
    public:
        ~GC()
        {
            Singleton::DelInstance();
        }
    };

    static GC gc;
    //定义一个全局的静态对象
    //main函数结束后会调用析构函数

    Singleton* Singleton::_pinst = nullptr;
    mutex Singleton::_mtx;
}
int main()
{
    //Singleton s1;
    //Singleton s2;
    //------------
    //cout << Singleton::GetInstance() << endl;
    //cout << Singleton::GetInstance() << endl;
    //cout << Singleton::GetInstance() << endl;
    //---------------
    //拷贝构造出来的是新的对象 拷贝构造也要禁掉
    //Singleton copy(*Singleton::GetInstance());
    
    vector<std::thread> vthreads;
    int n = 10;
    for (int i = 0; i < n; ++i)
    {
        vthreads.push_back(std::thread([]()
        {
            //cout << std::this_thread::get_id() << ":";
            cout << Lazy_Man::Singleton::GetInstance() << endl;
        }));
    }

    for (auto& t : vthreads)
    {
        t.join();
    }
    
    //有线程安全的问题
    //加锁

    return 0;
}

 

3°饿汉模式

namespace Hungry_Man
{
    //饿汉模式 一开始(main函数之前)就创建对象
    class Singleton
    {
    public:
        static Singleton* GetInstance()
        {
            return &_inst;
        }

        Singleton(const Singleton&) = delete;
    private:
        Singleton()
        {}

        static Singleton _inst;
    };

    Singleton Singleton::_inst;
    //static对象是在main函数之前创建的 这回只有主线程 所以不存在线程安全问题

    int test()
    {
        //Singleton s1;
        //Singleton s2;
        //------------
        //cout << Singleton::GetInstance() << endl;
        //cout << Singleton::GetInstance() << endl;
        //cout << Singleton::GetInstance() << endl;
        //---------------
        //拷贝构造出来的是新的对象 拷贝构造也要禁掉
        //Singleton copy(*Singleton::GetInstance());

        vector<std::thread> vthreads;
        int n = 10;
        for (int i = 0; i < n; ++i)
        {
            vthreads.push_back(std::thread([]()
                {
                    //cout << std::this_thread::get_id() << ":";
                    cout << Singleton::GetInstance() << endl;
                }));
        }

        for (auto& t : vthreads)
        {
            t.join();
        }

        //有线程安全的问题
        //加锁

        return 0;
    }
}

int main()
{
    Hungry_Man::test();
    //一开始就创建好了 没有线程安全问题
    return 0;
}

4°总结

总结对比一下饿汉和懒汉的区别

• 懒汉模式需要考虑线程安全和释放的问题 实现相对复杂 饿汉模式不存在以上问题 实现简单
• 懒汉是一种懒加载模式 需要时再初始化对象 不会影响程序的启动 饿汉模式则相反 程序启动阶段就创建初始化实例对象 会导致程序启动慢 影响体验
• 如果有多个单例类 假设有依赖关系(B依赖A) 要求A单例先创建初始化 B再启动 那么就不能用饿汉 因为无法保证初始化顺序 这个用懒汉我们就可以手动控制

总结一下:实际中懒汉模式还是更实用一些

2.类型转换

1°C/C++

int main()
{
    int i = 1;
    double d = 8.88;
    i = d;//类型转换 C语言支持相近类型的隐式类型转换(相近类型 也就是意义相似的类型)
    cout << i << endl;

    int* p = nullptr;
    p = (int*)i;//C语言支持相近类型的强制类型转换(不相近类型 也就是意义差别很大的类型)
    cout << p << endl;

    //C++ 兼容C语言留下来的隐式转换和显示转换 但是C++觉得C语言做得不规范 C++想兼容一下
    //引入了四种
    //static_cast,reinterpret_cast,const_cast,dynamic_cast
    
    d = static_cast<double>(i); //对应C语言隐式类型转换(相近类型)
    p = reinterpret_cast<int*>(i);//对应C语言大部分强制类型转换(不想近类型)
    
    //const int ci = 10;//加volatile可防止优化const 
    volatile const int ci = 10;
    //int* pi = (int*)&ci;//C语言
    int* pi = const_cast<int*>(&ci);//对应C语言强制类型转换中去掉const属性(不相近类型)
    *pi = 20;
    cout << *pi << endl;//20
    cout << ci << endl;//10 这里的打印10是因为ci存储的内存被改了 但是ci被放进了寄存器 这里去寄存器中取
    //还是19 本质是由于编译器对const对象存取优化机制导致
    //const变量先放进寄存器 内存当中改成了20 但取ci的时候是去寄存器里取得 所以还是10
    //想要禁止编译器做这个优化 每次都到内存中取值 就把volatile加上
    return 0;
}

static_cast、reinterpret_cast、const_cast、dynamic_cast

2°static_cast

static_cast用于非多态类型的转换（静态转换），编译器隐式执行的任何类型转换都可用st

atic_cast，但它不能用于两个不相关的类型进行转换

对应隐式类型转换

3°reinterpret_cast

reinterpret_cast操作符通常为操作数的位模式提供较低层次的重新解释，用于将一种类型

转换为另一种不同的类型

对应强制类型转换

4°const_cast

const_cast最常用的用途就是删除变量的const属性，方便赋值

去掉const属性

5°dynamic_cast

dynamic_cast用于将一个父类对象的指针/引用转换为子类对象的指针或引用(动态转换)

向上转型：子类对象指针/引用->父类指针/引用(不需要转换，赋值兼容规则)

向下转型：父类对象指针/引用-子类指针/引用(用dynamic_cast转型是安全的)

注意：

1. dynamic_cast只能用于含有虚函数的类
2. dynamic_cast会先检查是否能转换成功，能成功则转换，不能则返回0

class A
{
public:
    virtual void f()
    {}

protected:
    int _a;
};

class B :public A
{
protected:
    int _b;
};

void f_cast(A* pa)
{
    //如果想区分pa是指向父类还是子类对象?
    //B* pb = (B*)pa;
    //强转可能出问题
    //如果pa指向的是父类对象  
    //只会多看4个字节
    //但看不到_b
    B* pb = dynamic_cast<B*>(pa);
    //如果pa指向子类对象 则转换成功
    //如果pa指向父类对象 则转换失败 返回nullptr
    if (pb != nullptr)
    {
        cout << "转换成功:pa指向子类对象" << endl;
        //pb是指向子类 pa也指向子类 是可以转换的
    }
    else
    {
        cout << "转换失败:pa指向父类对象" << endl;
    }
}


int main()
{
    A a;
    B b;

    //C++子类对象可以赋值给父类的对象 指针 引用
    //这个过程会发生切片 这个过程是语法天然支持的 这个叫向上转换 都可以成功
    //如果是父类的指针或者引用 传给子类的指针 这个过程叫向下转换 这个过程有可能能成功
    //要看具体情况
    //最后需要注意的是:dynamic_cast向下转换只能针对继承中的多态类型(父类必须包含虚函数)
     //dynamic_cast如何识别父类的指针是指向父类对象还是子类对象的呢?
    //dynamic_cast的原理:dynamic_cast通过去找虚表的上方存储的标识信息
    //来判断指向父类对象还是子类对象
    A* pa = &a;
    f_cast(pa);
    pa = &b;
    f_cast(pa);

    return 0;
}

 

6°explicit

explicit关键字阻止经过转换构造函数进行的隐式转换的发生

class A
{
public:
    explicit A(int a)
    {
        cout << "A(int a)" << endl;
    }

    explicit A(int a1, int a2)
    {
        cout << "A(int a1, int a2)" << endl;
    }

    A(const A & a)
    {
        cout << "A(const A& a)" << endl;
    }

private:
    int _a1;
    int _a2;
};

int main()
{
    A a1(1);
    //隐式转换-> A tmp(1); A a2(tmp);
    //再优化成直接构造
    //A a2 = 1;
    //多个参数也可以防止隐式类型转换
    //A a3 = { 1,2 };//C++11
}

【C++】22.单例模式+类型转换 完