文章目录

• 📖 前言
• 1. 定制删除器
• • 1.1 仿函数解决：
• 2. C++的类型转换
• • 2.1 C语言的类型转换：
  • 2.2 C++四种类型转换：
  • • 2. 2 - 1 static_cast：
    • 2. 2 - 2 reinterpret_cast：
    • 2. 2 - 3 const_cast：
    • 2. 2 - 4 dynamic_cast：

📖 前言

上一章节我们学习了智能指针，我们可以将对象托管给智能指针管理，通过智能指针来释放资源空间。但是每个资源的释放的方式是不一样的，而我们之前实现的智能指针释放资源的方式单一，那我们该如何解决呢？下面来絮叨絮叨~~🙋🙋🙋🙌

智能指针复习：传送门

1. 定制删除器

class Date
{
public:~Date(){cout << "~Date()" << endl;}
private:int _year = 1;int _month = 1;int _day = 1;
};int main()
{//std版本：//传类型std::unique_ptr up1(new Date);//new和delete一定要匹配，不匹配不一定会报错std::unique_ptr up2(new Date[10]);//没报错，但是结果不对std::unique_ptr up3((Date*)malloc(sizeof(Date) * 10));//以读的方式打开了文件，有可能不匹配，有可能报错，有可能不报错，有可能正确释放，有可能不正确释放std::unique_ptr up4((FILE*)fopen("text.cpp", "r"));return 0;
}

如果只用单纯的智能指针默认的释放空间的方式，就会报错：

原因也很简单，unique_ptr只是用指向资源的指针来释放指向该资源，我们之前在C++内存管理中提到过，delete在释放空间时一定要匹配，不匹配可能会报错，可能不报错，这和编译器底层实现有关。

1.1 仿函数解决：

那我们的解决办法是用仿函数：

我们来看到标准库中就是用一个仿函数来实现不同资源的释放，那么我们就可以针对不同的资源写一个其对应的仿函数，专门用来释放该资源。

//写一个仿函数
template
struct DeleteArray
{void operator()(T* ptr){cout << "delete[]" << ptr << endl;delete[] ptr;}
};template
struct Free
{void operator()(T* ptr){cout << "free" << ptr << endl;free(ptr);}
};struct Fclose
{void operator()(FILE* ptr){cout << "fclose" << ptr << endl;fclose(ptr);}
};int main()
{//std版本：//传类型  std::unique_ptr up1(new Date);std::unique_ptr> up2(new Date[10]);std::unique_ptr> up3((Date*)malloc(sizeof(Date) * 10));std::unique_ptr up4((FILE*)fopen("text.cpp", "r"));return 0;
}

此时我们对自己实现的unique_ptr稍微修改一下，加一个带有删除器的功能即可：

namespace YY
{templatestruct default_delete{void operator()(T* ptr){delete ptr;}};//不能拷贝用unique_ptrtemplate>class unique_ptr{public://RAII思想unique_ptr(T* ptr):_ptr(ptr){}~unique_ptr(){if (_ptr){//cout << "delete：" << _ptr << endl;//delete _ptr;D del;del(_ptr);//仿函数_ptr = nullptr;}}//像指针一样T& operator*(){return *_ptr;}T* operator->(){return _ptr;}T* get(){return _ptr;}unique_ptr(const unique_ptr& sp) = delete;unique_ptr& operator=(const unique_ptr& sp) = delete;private:T* _ptr;};
}

上述unique_ptr是传类型，而shared_ptr是支持直接用对象构造的，这和底层实现有关…

2. C++的类型转换

2.1 C语言的类型转换：

类型转换：

在C语言中，如果赋值运算符左右两侧类型不同，或者形参与实参类型不匹配，或者返回值类型与接收返回值类型不一致时，就需要发生类型转化，C语言中总共有两种形式的类型转换：隐式类型转换和显式类型转换。

• 我们知道C++是兼容C语言的，而C语言是支持隐式类型转换的，这样的话就会发生一些意想不到的问题。
• 同时C语言还支持强制类型转换，但是只支持相近类型之间的强制类型转换，不同类型即使强转也转不了

1. 隐式类型转化： 编译器在编译阶段自动进行，能转就转，不能转就编译失败。
2. 显式类型转化： 需要用户自己处理。

缺陷：

• 转换的可视性比较差，所有的转换形式都是以一种相同形式书写，难以跟踪错误的转换。

举个栗子：

• 当一个int类型的变量和size_t类型的对象在一起时
• 会发生类型转换，将int整形转换成了size_t无符号整形

特别是在顺序结构插入的时候是最坑的：

原因：

如果要是在pos == 0的地方插入数据的话就相当于头插。这里的end会走到下标为0的位置，此时end再自减就为-1，因为end的类型为sizez_t（无符号整形）就会将-1的补码按照无符号整形解读成一个很大的数即（4294967295）那么循环永不停止，就是死循环。

如果将end的类型设置为int有符号整形即（int end = ps1->size - 1;）那当end为0时再次自减一次还会发生和上面一样的问题，因为这里发生了算数转换，当int类型的数据和size_t类型的数据进行比较时，int类型的数据要转换成size_t类型的数据这时-1又被转成很大的数即（4294967295）。循环不会止。

2.2 C++四种类型转换：

C风格的转换格式很简单，但是有不少缺点的：

1. 隐式类型转化有些情况下可能会出问题：比如数据精度丢失
2. 显式类型转换将所有情况混合在一起，代码不够清晰

因此C++提出了自己的类型转化风格，注意因为C++要兼容C语言，所以C++中还可以使用C语言的转化风格。

标准C++为了加强类型转换的可视性，引入了四种命名的强制类型转换操作符：

static_cast、reinterpret_cast、const_cast、dynamic_cast

2. 2 - 1 static_cast：

• static_cast用于非多态类型的转换（静态转换），编译器隐式执行的任何类型转换都可用
• static_cast，但它不能用于两个不相关的类型进行转换

int main()
{double d = 12.34;int a = static_cast(d);cout << a << endl;return 0;
}

2. 2 - 2 reinterpret_cast：

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

两个好不相关的变量C语言不支持直接强转：

int main()
{int a = 0;int* pa = &a;int aa = reinterpret_cast(pa);return 0;
}

2. 2 - 3 const_cast：

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

先来看一段程序：

int main()
{const int a = 0;int* pa = (int*)&a;*pa = 2;cout << a << endl;cout << *pa << endl;return 0;
}

运行结果就很让人摸不着头脑~~

解释：

• 这是编译器的优化，编译器看到是const的变量
• 绝大多数的情况const的变量是不会被修改的
• 所以访问a的时候没必要去内存中取
• 每次取会慢，所以要放在缓存当中去
• 有些会放到寄存器当中，有些是直接去取常量
• 就不会去内存中取，直接就变成2了
• 内存中修改了寄存器中却没修改

C++为了规范使用，建议在去掉变量const属性的时候加上const_cast。

int main()
{const int a = 2;int* p = const_cast(&a);*p = 3;cout << a << endl;return 0;
}

2. 2 - 4 dynamic_cast：

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

• 向上转型： 子类对象指针 / 引用->父类指针 / 引用（不需要转换，赋值兼容规则）
• 向下转型： 父类对象指针 / 引用->子类指针 / 引用（用dynamic_cast转型是安全的）

• 向上转型：对象指针指针或引用都支持
• 向下转型：对象不支持，只有指针和引用支持

注意：

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

应用场景：

• 当有一个父类对象的指针，请问该指针是指向父类对象还是指向子类对象呢？
• • 因为有向上转型的存在，所以父类指针支持指向子类对象
• • 按照我们以前学，只能实现一个多态，通过父类指针调用，指向谁调用谁

我们用dynamic_cast的方式：

• 转换成功（本来指向父类的，指向子类就转换成功）返回对象的地址
• 转换失败了就返回空指针

重点：

• 本身就是子类对象的指针，子类向上转型了，切片切割了，成父类指针了，再转回来，可以的（转回子类之后就向后多看一部分了）。
• 如果本身就是父类对象的指针，转成子类对象的指针，此时该指针就会向后多看了一部分，非父类对象的那部分，这就不安全了。

因为都是指针，所以要是真的强行将父类对象的指针强转成子类对象的指针，也是可以的，这样不安全，所以用dynamic_cast更好。

代码演示：

class A
{
public:virtual void f() {}
};class B : public A
{};void fun(A* pa)
{B* ptr = dynamic_cast(pa);//指向父类对象，强制转换成指向子类，导致可能会越界if (ptr){cout << "转换成功" << ptr << endl;}else{cout << "转换失败" << ptr << endl;}
}int main()
{A a;B b;fun(&a);fun(&b);return 0;
}