四、c++11智能指针之shared_ptr实现：自定义删除器

c++11智能指针之shared_ptr实现：自定义删除器

背景介绍：c++方向的硕士狗，实验室没什么c++项目，都是自学，在网上看到说智能指针这块挺重要的，自己也看了不少资料，觉得不如自己动手实战，从零到有实现一个shared_ptr。

规划：首先用c++11实现一个基本的智能指针，包括构造析构、拷贝移动等，然后往里面添加功能，如自定义删除器，支持数组管理的接口，以及目前我认为比较重要的多线程安全等等。最后采用c++17和20重构代码，看有没有什么需要改进的。

在代码实现中，我会一块附上如何调用这些接口，方便自己和大家学习

笔者也是刚入门c++，可能会有很多错误，欢迎大家指正，也欢迎大家一起学习，有任何问题可以留言评论

---

本节内容：本篇将会介绍在 系列文章一：基本功能，系列文章二：支持数组和常用接口 和 系列文章三：线程安全的基础上扩展 自定义删除器。

---

---

一、自定义删除器

到目前为止我们的类声明：

template<typename T>
class mySharedSp {
private:
	int* m_count; //指向计数器的指针
	T* m_ptr; //多个智能指针对象共享一个引用计数，因此要定义为指针
	size_t* m_size; //数组大小
	std::mutex* m_mutex; // 互斥锁，定义为指针类型，仅仅用来保护引用计数器

public:
	mySharedSp(T* p = NULL, size_t size = 0);  //构造
	mySharedSp(const mySharedSp<T>& other); //拷贝构造
	mySharedSp<T>& operator = (const mySharedSp<T>& other); //拷贝赋值
	mySharedSp(mySharedSp<T>&& other); //移动构造函数
	mySharedSp<T>& operator = (mySharedSp<T>&& other); //移动赋值
	~mySharedSp();// 析构

	// 操作符重载
	T& operator* () const;//解引用
	T* operator-> () const;//通过指针访问成员变量
	bool isNULL() const; //空指针检查
	int use_count() const; //获取引用值
	bool operator==(const mySharedSp<T>& other) const; //智能指针的比较操作
	bool operator!=(const mySharedSp<T>& other) const; //智能指针的比较操作
	
	// 迭代器
	using iterator = T*; // 将 iterator 定义为 T* 的别名
	using const_iterator = const T*; // 常量指针
	iterator begin(); // 常量对象调用
	iterator end();
	const_iterator begin() const; // 非常量对象只能调用这个，函数重载，根据对象的常量性选择不同版本，
	const_iterator end() const;

	// 数组操作
	T& operator[](size_t index) const; //通过 ptr[index] 访问数组元素
	size_t size() const; //获取数组大小
	void resize(int newSize); //动态调整数组的大小
	void reserve(int newSize); //预留空间
	void sort(iterator begin = m_ptr, iterator end = m_ptr + *m_size,
		bool (*comp)(const T&, const T&) = [](const T& a, const T& b) { return a < b; });  // 数组排序函数
	T* find(const T& value) const; //查找

private:
	void countAdd(); // 引用计数器加一
	void countDelete(); // 引用计数器减一
};

1. 自定义删除器是什么

自定义删除器就是在智能指针对象被销毁时可以自己定义 释放智能指针所指向资源的方式。

通常需要在 智能指针类中 定义一个删除器对象用来保存使用的删除器。

删除器对象可以是函数指针、函数对象、lambda表达式。

1. 函数指针是一个指向函数的指针。它可以用来间接调用函数。函数指针的类型取决于它所指向的函数的类型。函数指针的类型由返回类型和参数类型决定。例如，一个指向接受两个 int 类型的参数并返回 int 类型的函数的指针的类型为 int (*)(int, int)。

2. 函数对象是一个重载了 operator() 运算符的对象。它可以像函数一样被调用。例如，定义一个结构体 D，它重载了 operator() 运算符。然后，可以创建一个 D 类型的对象，并像调用函数一样调用它，例如 D d; int x = d(42)。函数对象的类型取决于它所属的类或结构体的类型。例如，如果您定义了一个结构体 D 并重载了 operator() 运算符，那么 D 类型的对象就是一个函数对象，它的类型为 D。

3. lambda 表达式本身没有类型，但是它可以被转换为一个函数指针或一个函数对象。当把一个 lambda 表达式赋值给一个函数指针或一个函数对象时，编译器会自动生成一个匿名的函数对象类型，并创建一个该类型的对象来表示 lambda 表达式。

    std::function<int(int, int)> f = [](int x, int y) { return x + y; };

比如这里定义了一个 lambda 表达式，它接受两个 int 类型的参数并返回它们的和。然后，将这个 lambda 表达式赋值给了一个 std::function<int(int, int)> 类型的变量。编译器会自动生成一个匿名的函数对象类型，并创建一个该类型的对象来表示 lambda 表达式。

2. 自定义删除器如何定义

由于自定义删除器有很多种，需要指定删除器对象的类型，以便编译器知道如何调用删除器来释放资源。因此这就意味着在构造的时候需要自己指定删除器类型，以及传入一个自定义的删除器对象。

a. 成员变量

首先定义一个 m_deleter 变量用于保存传入的自定义删除器对象，类型为 std::function<void(T*)> ，这意味着 m_deleter 可以存储任何可调用对象，只要这个可调用对象 接受一个 T* 类型的参数并返回 void 即可 。

std::function 是一个C++11引入的通用函数包装器，它可以存储任何可调用对象，包括函数指针、成员函数指针、lambda 表达式和函数对象。

b. 构造函数类内声明

为了支持自定义删除器，在构造函数中添加了一个参数 Deleter 来接收自定义删除器的类型。

说明一下为什么只在构造函数中添加额外的模板参数：就跟 mutex 一样，在构造函数中需要初始化mutex 和删除器对象，因此这里需要用户自己指定。而在拷贝，移动等，都是直接用其他智能指针对象现成的删除器对象，

构造函数的类内声明：

template<typename Deleter = std::default_delete<T>> // 成员函数模板 的 模板参数列表
mySharedSp(T* p = NULL, size_t size = 0, Deleter d = std::default_delete<T>()); 

1. template<typename Deleter = std::default_delete<T>> 这一行代码在构造函数中添加了一个除了指针管理对象类型 T 以外一个额外的模板参数 Deleter，它表示删除器的类型。
2. std::default_delete<T> 是一个默认的 删除器类型（注意这是一个类型），它使用 delete 操作符来释放资源。如果在创建智能指针时没有指定删除器类型，那么将使用这个默认的删除器类型。
3. Deleter 表示传入参数 d 这个删除器对象的类型。会根据传入的删除器类型自动判断 Deleter 的类型。
4. std::default_delete<T>() 是一个临时对象，表示使用 std::default_delete<T> 这个删除器类型 调用的默认构造函数 创建出来的临时删除器对象。当创建智能指针的时候不传入删除器对象，会使用这个默认构造函数创建出来的默认删除器对象。

在 C++ 中，类模板的成员函数也可以是模板函数。这意味着可以在类模板的成员函数中添加额外的模板参数。这样，只需要在使用构造函数创建智能指针对象时指定删除器的类型。在拷贝构造函数、移动构造函数和析构函数中，不需要指定删除器的类型。
比如，在调用构造函数的时候，要指定智能指针的类型为 mySharedSp<T, Deleter>，但是调用拷贝构造函数、移动构造函数和析构函数时，只需要将智能指针类型指定为 mySharedSp<T>。

有的地方设置参数d 的默认值会这样写：Deleter d = Deleter());
即用户在创建智能指针对象时没有传入删除器对象，那么将使用 Deleter() 来创建一个默认的删除器对象。Deleter() 是一个临时对象，它由 Deleter 类型的默认构造函数创建。
但是这样的话只能支持函数对象的传入，因为函数指针和 lambda 表达式都不是 类 类型，它们没有默认构造函数。
因此建议使用：Deleter d = std::default_delete<T>()

c. 构造函数类外定义

类外定义：

template<typename T> // 类模板 的 模板参数列表
template<typename Deleter> // 成员函数模板 的 模板参数列表
mySharedSp<T>::mySharedSp(T* p, size_t size, Deleter d) : 
	m_ptr(p), m_count(new int(1)), m_size(new int(size)), m_mutex(new mutex), m_deleter(d) {
	cout << "调用构造函数" << endl;

template<typename T> 表示 类模板 的 模板参数列表。它定义了类模板的一个模板参数 T，表示智能指针管理的对象的类型。

template<typename Deleter> 表示 成员函数模板 的 模板参数列表。它定义了成员函数模板的一个模板参数 Deleter，表示删除器的类型。

至于为什么将两个模板参数列表分开写，如果将两个模板参数列表合并为一个，例如 template<typename T, typename Deleter>，那么编译器会认为定义了一个新的类模板，它有两个模板参数 T 和 Deleter。这不是我们想要的结果。

3. 自定义删除器如何调用

上面说到，在构造的时候需要自己指定删除器类型，以及传入一个自定义的删除器对象。
比如传入一个 函数对象 作为删除器，那么需要指定 函数对象 的类型。
传入一个 函数指针 作为删除器，那么需要指定 函数指针 的类型。

比如：

// 定义了一个 T 类型，表示智能指针管理的对象
struct T {
    T() { std::cout << "T::T\n"; }
    ~T() { std::cout << "T::~T\n"; }
};

// 定义了一个函数
void TDeleter(T* p) {
    std::cout << "Calling TDeleter for T object... \n";
    delete p;
}

// 定义了一个结构体，封装了一个函数对象
struct D {
    void operator()(T* p) const {
        std::cout << "Calling delete for T object... \n";
        delete p;
    }
};

函数 TDeleter，它接受一个 T* 类型的参数并没有返回值。这个函数用于释放智能指针管理的资源。

结构体 D，它重载了 operator() 运算符。这个运算符接受一个 T* 类型的参数并没有返回值。这个运算符用于释放智能指针管理的资源。

int main() {
    // 传入 函数指针 作为删除器
    mySharedSp<T, void(*)(T*)> sp1(new T(), 0, TDeleter);

	// 传入 函数对象 作为删除器
    mySharedSp<T, D> sp2(new T(), 0, D());

	// 传入lambda表达式 作为删除器
    mySharedSp<T, std::function<void(T*)>> sp3(new T(), 0, [](T* p) {delete p;} );
}

在上面代码中，调用构造函数创建了三个智能指针对象。

a. 函数指针

智能指针对象sp1，传入的是一个函数指针 TDeleter（函数名 TDeleter 可以自动转换为指向该函数的指针）。它的类型由这个 函数的 返回值 和 传入的参数类型 决定，比如 函数 TDeleter，返回值是 void，传入的参数是指向T的指针 T 类型*，因此函数指针的类型为 void(*)(T*)。(*)表示这是一个指针。

b. 函数对象

智能指针对象sp2中，传入的是一个函数对象 D()，函数对象通常封装在类或结构体中，以便它们可以携带状态。传入的 D() 实际上是调用了 D 类型的默认构造函数来创建一个临时对象（因为平时是这样调用的：D d(); 这里没有给创建的对象命名，为临时调用）。这个临时对象被传递给构造函数，并用作删除器对象。而函数对象 D() 的类型为 D，D 是一个结构体类型。

c. lambda表达式

智能指针对象sp3中，传入的是一个lambda表达式，类型为 std::function<void(T*)>，其中 void 表示返回值，(T*) 表示lambda表达式传入的参数。我们将这个 lambda 表达式赋值给了一个 std::function<void(T*)> 类型的变量。编译器会自动为我们生成一个匿名的函数对象类型，并创建一个该类型的对象来表示 lambda 表达式。

d. 注意

在上面声明和定义中，有几点需要注意：

1. 在构造函数中，我们添加了一个模板参数 Deleter 并为其指定了默认删除器类型 std::default_delete<T> 这个类型。
2. 在构造函数中，我们将形参 d 定义为 Deleter d = std::default_delete<T>() 。这相当于设置了一个 默认的删除器对象。

基于此，我们在 调用构造函数 的时候可以：

1. 指定删除器类型，也传入删除器对象。
2. 只指定删除器类型，不传入删除器对象。 会使用默认的删除器对象 std::default_delete<T>()
3. 不指定删除器类型，只传入删除器对象。 编译器会根据传入的 对象 来推断模板参数 Deleter 的类型，而不是使用默认的 std::default_delete<T> 类型。
4. 不指定删除器类型，也不传入删除器对象。

比如：

// 定义了一个 T 类型，表示智能指针管理的对象
struct T {
    T() { std::cout << "T::T\n"; }
    ~T() { std::cout << "T::~T\n"; }
};

// 定义了一个函数
void TDeleter(T* p) {
    std::cout << "Calling TDeleter for T object... \n";
    delete p;
}

int main(){
	// 指定删除器类型，也传入删除器对象。
	mySharedSp<T, void(*)(T*)> sp1(new T(), 0, TDeleter);
	
	// 只指定删除器类型，不传入删除器对象。
	mySharedSp<T, void(*)(T*)> sp2(new T(), 0);
	
	// 不指定删除器类型，只传入删除器对象。
	mySharedSp<T> sp3(new T(), 0, TDeleter);
	
	// 不指定删除器类型，也不传入删除器对象。
	mySharedSp<T> sp4(new T(), 0);
}

当然，要是传入的是函数指针，但是指定的是函数对象类型，编译器在编译的时候会报错，这里不需要我们设置异常。

4. 析构函数的重构

这里是在析构函数中使用自定义删除器。

//析构
template<typename T>
mySharedSp<T>::~mySharedSp() {
	if (m_ptr == NULL) {
		cout << "指针为空，直接返回" << endl;
		delete m_count;
		m_count = NULL;
		delete m_size；
		m_size = NULL;
		delete m_mutex;
		m_mutex = NULL;
		return;
	}
	countDeleete();
}

// 引用计数器减一
template<typename T>
void mySharedSp<T>::countDelete() {
	{
		lock_guard<mutex> lock(*m_mutex);
		--(*m_count);
		bool ifDeleteMutex = false; 
		if (*m_count == 0) {
			m_deleter(m_ptr); // 使用自定义删除器
			delete m_count;
			m_count = NULL;
			delete m_size;
			m_size = NULL;
			ifDeleteMutex = true;
		}
	} 
	if (ifDeleteMutex) { 
		delete m_mutex;
		m_mutex = NULL;
	}
}

---

总结

本节是关于智能指针的自定义删除器，下一节会扩展一些其他功能，比如容器转换等。