特殊类的设计与类型转换
- 特殊类的设计
- 请设计一个类，只能在堆上创建对象
- 请设计一个类，只能在栈上创建对象
- 请设计一个类，只能创建一个对象(单例模式)
- C++的类型转换
特殊类的设计
请设计一个类，只能在堆上创建对象
通过new创建的类就是堆上的。
方法一：
#include<iostream>
using namespace std;
class HeapOnly
{
public:
static HeapOnly* func()//这里如果不用静态就无法创建对象了，也导致这个函数无法被调用
{
return new HeapOnly;
}
private:
HeapOnly()//防止随意的创建对象
{}
HeapOnly(const HeapOnly& a) = delete;//如果不删除拷贝函数创建的对象还是在栈上
};
int main()
{
HeapOnly* p1 = HeapOnly::func();
//HeapOnly p2(*p1);//这样避免了p2对象创建在栈上
return 0;
}
这里主要以封禁构造函数为主，让外部只能通过调用func函数方式去创建对象，func函数的内部是通过new创建的，这里要注意的就是拷贝构造的问题。
赋值重载不用删除，因为需要现有一个对象才能赋值给另一个对象，上面的代码只会创建出堆上的对象。
方法二：
#include<iostream>
using namespace std;
class HeapOnly
{
public:
HeapOnly()
{}
void Delete()
{
this->~HeapOnly();
}
private:
~HeapOnly()
{}
HeapOnly(const HeapOnly& a) = delete;
};
int main()
{
HeapOnly* p1 = new HeapOnly;
p1->Delete();
return 0;
}
封禁析构函数，需要自己手动释放内存。
请设计一个类，只能在栈上创建对象
这里要注意一点，静态区也不行。
方法一：
#include <iostream>
using namespace std;
class NonInherit
{
public:
static NonInherit func()
{
return NonInherit();
}
void Pintf()
{
cout << "Pintf" << endl;
}
private:
NonInherit()
{}
NonInherit(const NonInherit& p) = delete;
};
int main()
{
NonInherit::func().Pintf();
//static NonInherit p1 = NonInherit::func();//防止p1创建在静态区上
return 0;
}
这里就像匿名对象的感觉，如果不封拷贝构造就会出现注释上的问题。
方法二：
#include <iostream>
using namespace std;
class NonInherit
{
public:
static NonInherit func()
{
return NonInherit();
}
void Pintf() const
{
cout << "Pintf" << endl;
}
private:
NonInherit()
{}
NonInherit(const NonInherit& p) = delete;
};
int main()
{
const NonInherit& p1 = NonInherit::func();//用引用接收
p1.Pintf();//然后在使用
return 0;
}
请设计一个类，只能创建一个对象(单例模式)
设计模式：
设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。
单例模式：
一个类只能创建一个对象，即单例模式，该模式可以保证系统中该类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。比如在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息，这种方式简化了在复杂环境下的配置管理。
单例模式有两种实现模式：
饿汉模式
就是说不管你将来用不用，程序启动时就创建一个唯一的实例对象。
#include<iostream>
#include<map>
#include<string>
using namespace std;
class Singleton
{
public:
static Singleton& func()
{
return _a;//拿到对象本身
}
void Insert(string str, int salary)
{
arr[str] = salary;
}
void Printf()
{
for (auto& e : arr)
{
cout << e.first << ":" << e.second << endl;
}
}
private:
Singleton()
{}
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
map<string, int> arr;
static Singleton _a;
};
Singleton Singleton::_a;//在外部初始化对象，同类对象只会调用一次构造函数
int main()
{
Singleton::func().Insert("aaa", 111);
Singleton&p = Singleton::func();
p.Insert("bbb", 222);
p.Insert("ccc", 333);
p.Insert("ddd", 444);
p.Insert("eee", 555);
p.Printf();
return 0;
}
这个模式缺点：
如果数据量太大，启动就会非常的缓慢。
如果有多个文件一起，都有饿汉模式的代码，他们互相之间有依赖，但是编译器很难控制先初始化谁。
懒汉模式
如果单例对象构造十分耗时或者占用很多资源，比如加载插件啊， 初始化网络连接啊，读取文件啊等等，而有可能该对象程序运行时不会用到，那么也要在程序一开始就进行初始化，就会导致程序启动时非常的缓慢。 所以这种情况使用懒汉模式（延迟加载）更好。
#include<iostream>
#include<map>
#include<string>
#include<mutex>
using namespace std;
template<class T>
class Lock
{
public:
Lock(T& p)//因为锁不允许拷贝
:_p(p)
{
_p.lock();
}
~Lock()
{
_p.unlock();
}
private:
T& _p;//所以这里成员用引用
};
class Singleton
{
public:
static Singleton& func()
{
if (_a == nullptr)//避免每次调用的时候都进行加锁的操作，提高效率
{
Lock<mutex> p(mex);//用智能指针是为了防止下面的new出现异常导致未解锁
//如果不加锁，容易发生内存泄露，开辟多个空间，最终指针只会指向一处空间
if (_a == nullptr)//第一次调用创建对象
{
_a = new Singleton;
}
}
return *_a;
}
void Insert(string str, int salary)
{
arr[str] = salary;
}
void Printf()
{
for (auto& e : arr)
{
cout << e.first << ":" << e.second << endl;
}
}
private:
Singleton()
{}
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
map<string, int> arr;
static Singleton* _a;
static mutex mex;//锁
};
Singleton* Singleton::_a = nullptr;//在外部初始化对象，同类对象只会调用一次构造函数
mutex Singleton::mex;//定义锁
int main()
{
Singleton::func().Insert("aaa", 111);
Singleton& p = Singleton::func();
p.Insert("bbb", 222);
p.Insert("ccc", 333);
p.Insert("ddd", 444);
p.Insert("eee", 555);
p.Printf();
return 0;
}
并且，一般单例对象不用考虑释放，因为一个进程在结束的时候资源会回收给OS。
如果有需要处理的资源，需要在内部定义一个函数去处理某个资源，然后其他资源不用处理：
static void Delete()//手动释放资源
{
Lock<mutex> p(mex);
if (_a != nullptr)
{
delete _a;
_a = nullptr;
}
}
假如忘记回收这个资源了呢？
在内部定义一个GC的类，这个类的析构函数内部调用上面的Delete函数。
class GC
{
public:
~GC()
{
if (_a)
{
cout << "~GC()" << endl;
Delete();
}
}
};
然后再外部定义一个全局的GC类的对象，在程序结束的时候就会去调用析构函数。
主要是帮助检查有没有手动释放掉这一出资源。
注意：C++11前是无法保证线程静态的初始化是安全的，C++11之后可以。
也就是说懒汉还有这种写法：
static Singleton& func()
{
static Singleton _a;
return _a;
}
函数的成员也就不用了静态对象。
C++的类型转换
C语言有两种类型转换，一个是隐式类型转换，另一个是强制类型转换。
#include<iostream>
using namespace std;
int main()
{
//隐式类型
int a = 1;
double b = a;
//强制类型
int c = 10;
int* p = &c;
int d = (int)p;
return 0;
}
C++有四种类型转换，是期望大家能够规范使用的。
为什么C++需要四种类型转换
C风格的转换格式很简单，但是有不少缺点的：
1.隐式类型转化有些情况下可能会出问题：比如数据精度丢失。
2.显式类型转换将所有情况混合在一起，代码不够清晰。
因此C++提出了自己的类型转化风格，注意因为C++要兼容C语言，所以C++中还可以使用C语言的转化风格。
static_cast
static_cast用于非多态类型的转换（静态转换），编译器隐式执行的任何类型转换都可用。
static_cast，但它不能用于两个不相关的类型进行转换。
reinterpret_cast
reinterpret_cast操作符通常为操作数的位模式提供较低层次的重新解释，用于将一种类型转换
为另一种不同的类型。
const_cast
const_cast最常用的用途就是删除变量的const属性，方便赋值。
这里看起来并没有被赋值成功是因为编译器进行了优化，认为const的变量不会被修改，所以这个值一直放在了寄存器中，并没有从内存中获取，数据一直未被更新到寄存器当中。
dynamic_cast
dynamic_cast用于将一个父类对象的指针/引用转换为子类对象的指针或引用(动态转换)
向上转型：子类对象指针/引用->父类指针/引用(不需要转换，赋值兼容规则)
向下转型：父类对象指针/引用->子类指针/引用(用dynamic_cast转型是安全的)
注意：
1.dynamic_cast只能用于父类含有虚函数的类
2. dynamic_cast会先检查是否能转换成功，能成功则转换，不能则返回0
#include<iostream>
using namespace std;
class A
{
public:
virtual void f() {}
int a;
};
class B : public A
{
public:
int b;
};
void fun(A* pa)
{
// dynamic_cast会先检查是否能转换成功，能成功则转换，不能则返回
B* pb = dynamic_cast<B*>(pa);//子类指向父类，访问父类的内容的时候虚表可能会越界产生报错
if (pb)//检查是否合法，其实就是拒绝了子类指向父类
{
pb->a++;
pb->b++;
cout << "a++ " << "b++" << endl;
}
}
int main()
{
A a;
B b;
fun(&a);
fun(&b);
return 0;
}
注意：
强制类型转换关闭或挂起了正常的类型检查，每次使用强制类型转换前，程序员应该仔细考虑是
否还有其他不同的方法达到同一目的，如果非强制类型转换不可，则应限制强制转换值的作用
域，以减少发生错误的机会。强烈建议：避免使用强制类型转换。
