单例模式
概念
常用的一种典型的设计模式,单例模式的方法创建的类在当前进程中只有一个实例,一份资源只能被申请加载一次。
实现
- 饿汉模式:在资源的程序还在初始化的时候就会加载,保证后面能够直接进行使用。
(不涉及线程安全问题 )
优:使用的过程流畅
缺:可能会加载很多不需要的资源,导致程序初始化缓慢 - 懒汉模式: 资源在使用的过程中发现还没加载则申请加载。(游戏中常用且涉及线程安全)
优:程序初始化快
缺:使用过程中衔接不流程,并且在第一次运行某个模块时会比较缓慢,因为此时正在加载相应的资源
总结对比一下饿汉和懒汉的区别
1、懒汉模式需要考虑线程安全和释放的问题,实现相对更复杂,饿汉模式不存在以上问题,实现简单
2、懒汉是一种懒加载模式需要时在初始化创建对象,不会影响程序的启动。饿汉模式则相反,程序启动阶段就创建初始化实力对象,会导致程序启动慢,影响体验。
3、如果有多个单例类,假设有依赖关系(B依赖A),要求A单例先创建初始化,B单例再创建初始化,那么就不能饿汉,因为无法保证创建初始化顺序,这时用懒汉我们就可以手动控制。
总结一下:实际中懒汉模式还是更实用一些
饿汉模式
namespace hungry_man
{
class Singleton
{
public:
static Singleton* Git()
{
return &_sl;
}
Singleton(const Singleton&) = delete;
private:
Singleton() {};
static Singleton _sl;
};
Singleton Singleton::_sl; //在main函数之前就已经定义好了,故不涉及线程安全问题
void x()
{
int n = 1000;
auto a1 = [&]()
{
for (int i = 0; i < n; ++i)
{
cout << hungry_man::Singleton::Git() << endl;
}
};
thread t1(a1);
t1.join();
}
}
int main()
{
hungry_man::x();
return 0;
}
懒汉模式
#include <iostream>
#include <mutex>
#include <thread>
#include <vector>
using namespace std;
namespace lazy_man
{
class Singleton
{
public:
static Singleton* Git()
{
if (_sl == nullptr) //二次判断,省去不必要的加锁解锁时间
{
//unique_lock每次在构造时会自动加锁,析构时自动解锁
unique_lock<mutex> lock(_mtx); //不用_mtx.lock()是万一new抛异常无法解锁导致阻塞
if (_sl == nullptr)
{
_sl = new Singleton;
}
}
return _sl;
}
static void Release()
{
cout << "delete" << endl;
delete _sl;
_sl = nullptr;
}
private:
Singleton() {}; //保证只有一个对象
static Singleton* _sl;
static mutex _mtx;
};
Singleton* Singleton::_sl = nullptr;
mutex Singleton::_mtx;
class release //设置release是为了在退出时自动释放单例对象
{
public:
~release()
{
Singleton::Release();
}
};
static release rs;
void x()
{
int n = 10000;
auto a1 = [&]()
{
for (int i = 0; i < n; ++i)
{
cout << lazy_man::Singleton::Git() << endl;
}
};
thread t1(a1);
t1.join();
}
}
int main()
{
lazy_man::x();
return 0;
}
类型转换
为什么C++需要四种类型转换
C风格的转换格式很简单,但是有不少缺点的:
- 隐式类型转化有些情况下可能会出问题:比如数据精度丢失
- 显式类型转换将所有情况混合在一起,代码不够清晰
因此 C++ 提出了自己的类型转化风格,注意因为 C++ 要兼容C语言,所以 C++ 中还可以使用C语言的转化风格
标准C++为了加强类型转换的可视性,引入了四种命名的强制类型转换操作符:
- static_cast、reinterpret_cast、const_cast、dynamic_cast
1.static_cast
tatic_cast用于非多态类型的转换(隐式类型转换),编译器隐式执行的任何类型转换都可用static_cast,但它不能用于两个不相关的类型进行转换。
int main()
{
double d = 12.34;
int a = static_cast<int>(d);
cout << a << endl;
return0;
}
2.reinterpret_cast
reinterpret_cast操作符通常为操作数的位模式提供较低层次的重新解释,用于将一种类型转换为另一种不同的类型(强制类型转换)。
int main()
{
char c = 'a';
int* p = reinterpret_cast<int*>(&c);
cout << *p << endl;
}
3.const_cast
const_cast最常用的用途就是删除变量的const属性,方便赋值
int main()
{
const int a = 10;
int* p = const_cast<int*>(&a);
*p = 20;
cout << *p << endl; //20
cout << a << endl; //10
//p本应该指向a的地址,但是为什么*p = 20,而a却还等于10呢?
//其实a也变成20了,但是因为a作为常量,被存放在缓存寄存器中,访问的时候只需要去寄存器中取就行,节省了去内存读取的时间,而p却需要去内存中读取
//只需要把第一句改为volatile const int a = 10; 就可以看到a变成了20,volatile的作用我前面博客有讲,想了解的可以去看看
}
4.dynamic_castd
dynamic_cast用于将一个父类(基类)对象的 指针/引用 转换为子类(派生类)对象的 指针或引用 (动态转换)
向上转型:子类对象指针/引用->父类指针/引用(不需要转换,赋值兼容规则)
向下转型:父类对象指针/引用- >子类指针/引用 (用dynamic_cast转型是安全的)
注意:
- dynamic_cast 只能用于含有虚函数的类
- dynamic_cast 会先检查是否能转换成功,能成功则转换,不能则返回 nullptr
class Father
{
public:
virtual void f() {}
};
class Son : public Father
{};
void fun(Father* pa)
{
// dynamic_cast会先检查是否能转换成功,能成功则转换,不能则返回nullptr
Son* pb2 = dynamic_cast<Son*>(pa);
if (pb2 == nullptr)
cout << "转换失败,该指针原本指向父亲" << endl;
else
cout << "转换成功,该指针原本指向儿子" << endl;
}
int main()
{
Father fa;
Son so;
fun(&fa); //失败
fun(&so); //成功
return 0;
}
总结: dynamic_cast 虽然说将基类的指针/引用转换为派生类的指针/引用,但实际上因为基类无法满足派生类的大小需求而为了保障安全,所以仍然不能转换,只有派生类的指针/引用转换为派生类的指针/引用时才会成功。
5.explicit
用于阻止经过转换构造函数进行的隐式转换的发生
class A
{
public:
explicit A(int a)
{
cout << "A(int a)" << endl;
}
A(const A& a)
{
cout << "A(const A& a)" << endl;
}
private:
int _a;
};
int main()
{
A a1(1);
// 隐式转换-> A tmp(1); A a2(tmp);
A a2 = 1;
}
特殊类设计
1.设计一个类,要求该类只能在堆上创建对象。
思路:首先什么情况下对象会创建在堆上,那就是 new 或者 malloc 出的对象,其次我们无法保证构造函数创建的对象一定在堆上,并且拷贝构造出来的对象是在栈上的,所以我们需要私有化构造函数和拷贝构造,不让用户去进行。
class HeapOnly
{
public:
static HeapOnly* Git() //设置成静态是为了不使用对象也能直接调用
{
return new HeapOnly;
}
HeapOnly(const HeapOnly&) = delete; //禁用拷贝构造
private:
HeapOnly(); //私有化构造函数
};
2.设计一个类,要求该类只能在栈上创建对象。
思路:1.同样为了防止构造函数处出问题,我们要私有化构造函数。2.保证创建在栈上只要私有化 new 和 delete 就能得到保障(但是不能禁止全局变量)。
//方法一,私有化构造函数
class StackOnly
{
public:
static StackOnly Git()
{
return StackOnly();
}
private:
StackOnly() {}; //私有化构造函数
};
//方法二,
class StackOnly
{
public:
StackOnly() {};
private:
void* operator new(size_t size); //面对全局变量会有一点问题
void operator delete(void* p);
};
3.设计一个不能被拷贝的类
class No_Copy
{
public:
No_Copy() {};
No_Copy(const No_Copy&) = delete;
No_Copy& operator=(const No_Copy&) = delete;
}
4.设计一个不能被继承的类
class No_PerSon final
{
}