【C++】定制删除器 + 类型转换

📖 前言

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

智能指针复习：传送门

---

1. 定制删除器

class Date
{
public:
	~Date()
	{
		cout << "~Date()" << endl;
	}
private:
	int _year = 1;
	int _month = 1;
	int _day = 1;
};

int main()
{
	//std版本：
	
	//传类型
	std::unique_ptr<Date> up1(new Date);

	//new和delete一定要匹配，不匹配不一定会报错
	std::unique_ptr<Date> up2(new Date[10]);

	//没报错，但是结果不对
	std::unique_ptr<Date> up3((Date*)malloc(sizeof(Date) * 10));

	//以读的方式打开了文件，有可能不匹配，有可能报错，有可能不报错，有可能正确释放，有可能不正确释放
	std::unique_ptr<FILE> up4((FILE*)fopen("text.cpp", "r"));
	
	return 0;
}

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

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

---

1.1 仿函数解决：

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

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

//写一个仿函数
template<class T>
struct DeleteArray
{
	void operator()(T* ptr)
	{
		cout << "delete[]" << ptr << endl;

		delete[] ptr;
	}
};

template<class T>
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<Date> up1(new Date);

	std::unique_ptr<Date, DeleteArray<Date>> up2(new Date[10]);

	std::unique_ptr<Date, Free<Date>> up3((Date*)malloc(sizeof(Date) * 10));

	std::unique_ptr<FILE, Fclose> up4((FILE*)fopen("text.cpp", "r"));

	return 0;
}

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

namespace Joker
{
	template<class T>
	struct default_delete
	{
		void operator()(T* ptr)
		{
			delete ptr;
		}
	};

	//不能拷贝用unique_ptr
	template<class T, class D = default_delete<T>>
	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<T>& sp) = delete;
		unique_ptr<T>& operator=(const unique_ptr<T>& 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<int>(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<int>(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<int*>(&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<B*>(pa);
	//指向父类对象，强制转换成指向子类，导致可能会越界
	if (ptr)
	{
		cout << "转换成功" << ptr << endl;
	}
	else
	{
		cout << "转换失败" << ptr << endl;
	}
}

int main()
{
	A a;
	B b;

	fun(&a);
	fun(&b);

	return 0;
}