C++学习记录——삼십일 特殊类设计和类型转换
文章目录
- 1、特殊类设计
-
- 1、无法拷贝的类
- 2、只能在堆上创建对象的类
- 3、只能在栈上创建对象的类
- 4、不能被继承的类
- 5、单例模式
-
- 1、饿汉模式
- 2、懒汉模式
- 3、饿汉懒汉优缺点
- 4、对象释放
- 5、拷贝构造
- 2、类型转换
-
- 1、C和C++的类型转换对比
- 2、static_cast
- 3、reinterpret_cast
- 4、const_cast
- 5、dynamic_cast
- 6、RTTI
1、特殊类设计
1、无法拷贝的类
设置成私有；只声明不定义；默认成员函数后加上delete，表示删除此函数，也就不会被拷贝了。
2、只能在堆上创建对象的类
我们可以把析构函数放在私有，但因为每个对象都被要求显式调用析构函数，所以只能new一个对象，但是释放时又不能delete，所以只能在类内写一个销毁用的函数。
class HeapOnly
{
public:
void Destroy()
{
delete this;
}
private:
~HeapOnly()
{
cout << "~HeapOnly" << endl;
}
int _x;
};
int main()
{
HeapOnly* pho = new HeapOnly;
pho->Destroy();
return 0;
}
另一个思路是构造函数放在私有里，这样即使是new也不行，只能在类内写一个初始化用的函数，在类内new一个。
class HeapOnly
{
public:
HeapOnly* Create(int x = 0)
{
HeapOnly* p = new HeapOnly(x);
return p;
}
private:
HeapOnly(int x = 0)
:_x(x)
{}
int _x;
};
int main()
{
Create(10);
return 0;
}
但是这样会出错，调不动这个Create函数，因为没法实例化对象，也就不能调用类内成员函数。我们可以把Create函数变成static修饰的来解决，但这个方法还是有坑，因为我们可以拷贝到一个新对象里，这个新对象就会创建在栈里，可以加delete来禁止。
class HeapOnly
{
public:
static HeapOnly* Create(int x = 0)
{
HeapOnly* p = new HeapOnly(x);
return p;
}
private:
HeapOnly(int x = 0)
:_x(x)
{}
HeapOnly(const HeapOnly& hp) = delete;
HeapOnly& operator=(const HeapOnly& hp) = delete;
int _x;
};
int main()
{
HeapOnly* p1 = HeapOnly::Create(10);
//HeapOnly p2(*p1);
return 0;
}
3、只能在栈上创建对象的类
把构造函数封掉，那么正常的创建对象方式都没用了，只能借助成员函数来创建，这时候就可以自主选在堆还是栈创建。
class StackOnly
{
public:
static StackOnly Create(int x = 1)
{
return StackOnly(x);
}
private:
StackOnly(int x = 0)
:_x(x)
{}
int _x;
};
int main()
{
StackOnly so1 = StackOnly::Create(10);
return 0;
}
虽然这样可以在栈上创建，但是也无法阻止在堆上创建，比如这样写：static StackOnly so2 = so1，但是我们也不能封拷贝构造，把拷贝构造放在私有里，因为这样Create函数没法传回来对象了。那既然拷贝构造被禁掉了，就加个移动构造，在公有里加个这样的函数
StackOnly(StackOnly&& st)
:_x(st._x)
{
}
但是这样也不行，还可以用move的左值来构造。
这方面确实没办法彻底封死。做到这里也就行了。
4、不能被继承的类
构造函数被封掉，也就是给私有化了，也就行了，因为派生类必须调用基类的构造。另外一个办法就是在类后加上final，比如class A final。
5、单例模式
设计模式是代码设计的一些总结，通过长期的实践经验而总结出来的代码格式。适配器，迭代器都是设计模式，单例模式也是设计模式，另外还有工厂、观察者模式。
单例模式是设计一个在一个进程中只能创建一个对象的类。在多线程中使用得多。像内存池，每个线程都去访问它，线程池只需要一份即可，内存池就可以设计成单例模式。
单例模式有两类饿汉模式，懒汉模式。先看饿汉模式
1、饿汉模式
class Singleton
{
public:
static Singleton* GetInstance()
{
}
private:
Singleton()//限制类外面随意创建对象
{}
private:
int _n = 0;
vector<string> _v;
};
get函数里要如何限制住只能访问一个对象？我们可以在私有里声明一个静态区的变量，在类外面再去定义它。
class Singleton
{
public:
static Singleton* GetInstance()
{
return _ins;
}
private:
Singleton()//限制类外面随意创建对象
{}
private:
int _n = 0;
vector<string> _v;
static Singleton* _ins;
};
Singleton* Singleton::_ins = new Singleton;
int main()
{
Singleton::GetInstance();
return 0;
}
虽然_ins是静态区的，但也是类内的，可以new去初始化它，这里是一个声明定义分离。
在类外面，只能调用get函数来创建这个类的对象，但还不能直接去操作_v和_ins，我们也没有可使用的对象，所以一切操作就得在类内的public内实现。
class Singleton
{
public:
static Singleton* GetInstance()
{
return _ins;
}
void Add(const string& str)
{
_v.push_back(str);
++_n;
}
void Print()
{
for (auto& e : _v)
{
cout << e << " ";
}
cout << endl;
}
private:
Singleton()//限制类外面随意创建对象
{}
private:
int _n = 0;
vector<string> _v;
static Singleton* _ins;
};
Singleton* Singleton::_ins = new Singleton;
int main()
{
Singleton::GetInstance()->Add("a");
Singleton::GetInstance()->Add("b");
Singleton::GetInstance()->Add("c");
Singleton::GetInstance()->Print();
return 0;
}
加入多线程场景和锁。
#include 这是一个饿汉模式，在main函数之前就创建对象了，new那一句就是在创建对象，这样对应着饿这个字的意思。
2、懒汉模式
顾名思义，它是需要时才创建对象。
class Singleton
{
public:
static Singleton* GetInstance()
{
if (_ins == nullptr)
{
_ins = new Singleton;
}
return _ins;
}
//......
Singleton* Singleton::_ins = nullptr;
3、饿汉懒汉优缺点
饿汉在你没使用前就创建了，不管用户需不需要。饿汉的问题在于，如果单例对象很大，那么一开始申请就会占用资源，也会降低程序启动速度。
如果两个单例都是饿汉模式，并且有依赖关系，要求单例2先创建，再创建单例1，那么饿汉就无法控制顺序。
饿汉的优点就是简单。
懒汉的缺点在于创建对象时会有线程安全问题，如果t1在new时，还没new完就被切走，t2过来new，然后插入数据，t1回来后会再次new一遍，那么t2之前的数据就被覆盖了，没了，所以需要加锁。由于懒汉在new之前还没有创建对象，所以得在priavte里创建一个静态区的锁，然后在外面给初始化。
class Singleton
{
public:
static Singleton* GetInstance()
{
_imtx.lock();
if (_ins == nullptr)
{
_ins = new Singleton;
}
return _ins;
_imtx.unlock();
}
void Add(const string& str)
{
_vmtx.lock();
_v.push_back(str);
++_n;
_vmtx.unlock();
}
void Print()
{
_vmtx.lock();
for (auto& e : _v)
{
cout << e << endl;
}
_vmtx.unlock();
}
private:
Singleton()//限制类外面随意创建对象
{}
private:
mutex _vmtx;
int _n = 0;
vector<string> _v;
static Singleton* _ins;
static mutex _imtx;
};
Singleton* Singleton::_ins = nullptr;
mutex Singleton::_imtx;//初始化了锁
现在我们写的懒汉模式还有问题吗？每一次获取对象都要加锁解锁，但我们只有第一次加锁解锁，那么把锁放在if代码块里可行吗？也不行，线程不安全。只要是只需要第一次加锁的都可以这样写
static Singleton* GetInstance()
{
//双检查加锁
if (_ins == nullptr)
{
_imtx.lock();
if (_ins == nullptr)//保证线程安全和new一次
{
_ins = new Singleton;
}
_imtx.unlock();
}
return _ins;
}
懒汉模式解决了饿汉的问题，不过相对复杂点，实际生活中大都使用懒汉。
另外一种懒汉设计
class Singleton
{
public:
static Singleton* GetInstance()
{
static Singleton inst;
return &inst;
}
void Add(const string& str)
{
_vmtx.lock();
_v.push_back(str);
++_n;
_vmtx.unlock();
}
void Print()
{
_vmtx.lock();
for (auto& e : _v)
{
cout << e << endl;
}
_vmtx.unlock();
}
~Singleton()
{
;
}
//防拷贝
Singleton(const Singleton& s) = delete;
Singleton& operator=(const Singleton& s) = delete;
private:
Singleton()
{
cout << "Singleton" << endl;
}
mutex _vmtx;
int _n = 0;
vector<string> _v;
};
局部的静态对象，出了作用域就会自动销毁，也不需要内部类。C++11之后这种方式就可以保证线程安全，C++11中局部静态变量是线程安全的，多线程来调用，只会让一个线程进去函数。
4、对象释放
单例对象不释放，因为全局都要使用它，只有确定不使用它了就可以释放它，这个接口也得在类内定义。
static void DelInstance()
{
_imtx.lock();
if (_ins)
{
delete _ins;
_ins = nullptr;
}
_imtx.unlock();
}
释放时也有可能特殊要求，析构时要求持久化，也就是里面的数据存到另一个地方去。但是需要每次都调用DelInstance函数，就自动调用析构，完成要求，但如果忘了呢？我们可以定义一个内部类，然后定义一个全局或者静态的内部类对象。
class Singleton
{
public:
static Singleton* GetInstance()
{
//双检查加锁
if (_ins == nullptr)
{
_imtx.lock();
if (_ins == nullptr)
{
_ins = new Singleton;
}
_imtx.unlock();
}
return _ins;
}
void Add(const string& str)
{
_vmtx.lock();
_v.push_back(str);
++_n;
_vmtx.unlock();
}
void Print()
{
_vmtx.lock();
for (auto& e : _v)
{
cout << e << endl;
}
_vmtx.unlock();
}
static void DelInstance()
{
_imtx.lock();
if (_ins)
{
delete _ins;
_ins = nullptr;
}
_imtx.unlock();
}
//单例对象回收
class GC
{
public:
~GC()
{
DelInstance();
}
};
static GC _gc;//定义一个全局或者静态的内部类对象
private:
Singleton()//限制类外面随意创建对象
{}
private:
mutex _vmtx;
int _n = 0;
vector<string> _v;
static Singleton* _ins;
static mutex _imtx;
};
Singleton* Singleton::_ins = nullptr;
mutex Singleton::_imtx;//初始化了锁
Singleton::GC Singleton::_gc;//创建了内部类对象，出了作用域就会自己调用析构
如果忘记了调用释放函数，那么它就可以自动析构，如果没忘记，也没关系，内部类对象析构时会再次调用，然后发现_ins会空，就会什么都不做，解锁。
5、拷贝构造
单例模式还要禁止拷贝构造。有锁的话没法拷贝构造，因为锁不允许拷贝。假设没有锁，我们就要防拷贝。饿汉懒汉都要做。
Singleton(const Singleton& s) = delete;
Singleton& operator=(const Singleton& s) = delete;
特殊类设计代码
2、类型转换
1、C和C++的类型转换对比
void Test()
{
int i = 1;
//隐式类型转换
double d = i;
printf("%d %.2f\n", i, d);
int* p = &i;
//显式类型转换
int pa = (int)p;
printf("%x, %d\n", p, pa);
}
int main()
{
Test();
return 0;
}
C语言中相关的类型才能进行转换，但会出现隐式类型提升这个坑点。
C++要兼容C语言，还要解决C语言这方面隐式会导致精度丢失，显式会使代码不够清晰的问题，引入了强制类型转换，static_cast，reinterpret_cast，const_cast，dynamic_cast，四者各有用处，且不能互相套着用。
2、static_cast
用于非多态类型的转换（静态转换），其实就是以前的隐式类型转换，和隐式一样，不能用于两个不相关的类型进行转换，但解决了精度问题。
double d = 12.34;
int a = static_cast<int>(d);
cout << a << endl;
3、reinterpret_cast
适用于不相关类型的转换，意思是重新解释。
double d = 12.34;
int a = static_cast<int>(d);
cout << a << endl;
int* p = reinterpret_cast<int*>(a);
4、const_cast
用于去掉const属性。
const int a = 2;
int* p = const_cast<int*>(&a);
*p = 3;
cout << a << endl;
cout << *p << endl;
实际上这个代码没有改变a的值，但是*p是3。a确实被修改了，但因为const会被编译器优化，默认识别成不能修改的，比如有的编译器会把代码出现a的地方直接替换成2，所以打印出来还是2，也有可能是把a的值放进寄存器中，每次访问都是访问寄存器，所以改了也没用，要解决这个问题，就是加volatile，禁止编译器优化，每次都去内存中访问a的值。
如果我们强制类型转换，int* p = (int*)&a，其实也可以。只是为了统一规范，C++就用const_cast来做。
5、dynamic_cast
C++独有的转换，动态转换，用于基类对象的指针/引用转换为派生类对象的指针或引用。派生类转基类语法本身就支持，而动态转换是解决基类转派生类的。但是无论如何，类对象之间是不能转换的。
class A
{
public:
virtual void f(){};
};
class B : public A
{};
void fun(A* pa)
{
B* pb1 = static_cast<B*>(pa);//(B*)(pa)也行
B* pb2 = dynamic_cast<B*>(pa);
cout << "pb1:" << pb1 << endl;
cout << "pb2:" << pb2 << endl;
}
int main()
{
A a;
B b;
fun(&a);
fun(&b);
return 0;
}
父类指针如果指向子类对象，那么它转子类指针是安全的，用static_cast都可，但如果本身指向父类对象，那么转子类指针就不安全，因为访问子类成员时可能会越界。动态转换如果检测指向父类对象就会转换失败，如果指向子类对象就会转换成功。
可以这样写来查看结果
class A
{
public:
virtual void f(){};
};
class B : public A
{};
void fun(A* pa, const string& s)
{
cout << "pa指向" << s << endl;
B* pb1 = (B*)pa;
B* pb2 = dynamic_cast<B*>(pa);
cout << "[强制转换]pb1:" << pb1 << endl;
cout << "[dynamic_cast转换]pb2:" << pb2 << endl;
}
int main()
{
A a;
B b;
fun(&a, "父类对象");
fun(&b, "子类对象");
return 0;
}
6、RTTI
运行时类型识别。RAII是利用对象来管理资源。RTTI通过typeid，dynamic_cast，decltype来支持。
//用上一段代码
int main()
{
A a;
B b;
fun(&a, "父类对象");
fun(&b, "子类对象");
cout << typeid(a).name() << endl;//对象类型的字符串
decltype(a) aa;//获取类型当作aa的类型，用来获取一些不好直接写出来的类型
function<bool(int,int)> gt = [](int x, int y) {return x > y; };
set<int, decltype(gt)> s;
return 0;
}
类型转换代码
结束。