理解并简单实现智能指针（暂不考虑多线程安全

Dave_L

已于 2022-03-21 11:26:18 修改

阅读量236

点赞数

CC 4.0 BY-SA版权

分类专栏：泛型编程文章标签： c++

于 2021-01-24 15:53:03 首次发布

本文为博主原创文章，未经博主允许也可以转载。

本文链接：https://blog.csdn.net/FrankAx/article/details/113085503

泛型编程专栏收录该内容

5 篇文章

订阅专栏

本文介绍了智能指针的基本概念，如auto_ptr的使用和潜在问题，然后重点讨论了unique_ptr和shared_ptr的出现，特别是shared_ptr如何通过共享计数解决多个指针共享资源的问题。作者详细展示了shared_ptr的实现，包括模板构造、移动构造函数以及类型转换操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

智能指针就是RAII资源管理的自然体现。

首先，一个简易的auto_ptr，包含初始化、拷贝、赋值等基本操作。

#include <iostream>
using namespace std;

class shape {public:  virtual ~shape() {}};
class circle : public shape {public:  ~circle() { puts("~circle()"); }};

template<typename T>
class smart_ptr {
public:
	explicit smart_ptr(T *ptr = nullptr):ptr_(ptr) {}
	~smart_ptr(){
		delete ptr_;
	}

	// ctor 
	// 源对象释放对指针的所有权，新对象接受源指针资源
	smart_ptr(smart_ptr &other) {
		ptr_ = other.release();
	}

	// copy and swap
	// 分为拷贝构造 + 交换 ， 异常只会出现在第一步，若出现异常能够保证*this不受到干扰
	// 可以直接不传入引用，自动构造副本，但可读性会差点
	/*
	smart_ptr& operator=(smart_ptr rhs) {
		rhs.swap(*this);	// rhs已经调用了构造函数创造副本
		return *this;
	}
	*/
	smart_ptr& operator=(smart_ptr &rhs) {
		smart_ptr(rhs).swap(*this);
		return *this;
	}

	// 释放它对指针的所有权
	T* release() {
		T *ptr = ptr_;
		ptr_ = nullptr;
		return ptr;
	}

	void swap(smart_ptr &rhs) {
		using std::swap;
		swap(ptr_, rhs.ptr_);
	}

	T* get() const {return ptr_;}
	T& operator*() const {return *ptr_;}
	T* operator->() const {return ptr_;}
	operator bool() const {return ptr_;}	// 实现bool类型的隐式转换，如if(ptr1){...}
private:
	T* ptr_;
};

int main() {
	smart_ptr<circle>ptr1(new circle());
	smart_ptr<circle>ptr2;
	ptr2 = ptr1;
	cout << (ptr1 ? "non-empty" : "empty") << endl;
	cout << (ptr2 ? "non-empty" : "empty") << endl;
	
	return 0;
}

在这里插入图片描述
这种auto_ptr的行为会让程序员非常容易犯错。一不小心把它传递给另外一个 smart_ptr，你就不再拥有这个对象了.

因此就有了unique_ptr , 也是同时只能有一个指针保留资源，但是它采用移动构造函数，禁用拷贝构造函数（若提供了移动构造函数而没有手动提供拷贝构造函数，那后者自动被禁用）。因此使用更加安全可控。

其只需要将auto_ptr版本的smart_ptr的拷贝构造函数更改为移动构造函数.
即将参数改为右值引用的形式，并且不自定义拷贝构造函数。

smart_ptr(smart_ptr &&other) {
	ptr_ = other.release();
}

此时，若通过普通方法构造新的对象：
如通过ptr1构造ptr2：

smart_ptr<circle>ptr1{new circle()};	// c++11 {}和()初始化作用相同
smart_ptr<circle>ptr2{ptr1};

会报错：
在这里插入图片描述
大意就是提供了移动构造函数而没有手动提供拷贝构造函数，那后者自动被禁用（delete），因此通过拷贝构造函数构造ptr2行不通。

smart_ptr<circle>ptr1{new circle()};
smart_ptr<circle>ptr2(std::move(ptr1));

通过std::move()将ptr1转化成右值引用
并通过这一动作，让coder明白造成的后果，右值意味着是临时的，不能指望ptr1赋值过后的结果。

unique_ptr算是一种较为安全的智能指针了。但是，一个对象只能被单个unique_ptr所拥有，这显然不能满足所有使用场合的需求。
一种常见的情况是，多个智能指针同时拥有一个对象；当它们全部都失效时，这个对象也同时会被删除。
这就是shared_ptr 。

在这里插入图片描述
多个不同的shared_ptr不仅可以共享一个对象，在共享同一对象时也需要同时共享同一个计数。当最后一个指向对象（和共享计数）的 shared_ptr 析构时，它需要删除对象和共享计数。

一个简单的shared_ptr实现：
添加了子类向基类的转化（通过添加模板构造、移动函数）、以及共享计数、强制类型转换相关的操作。

#include <iostream>
using namespace std;

class shape {public:  virtual ~shape() {}};
class circle : public shape {public:  ~circle() { puts("~circle()"); }};

// 共享计数
class shared_count {
public:
	shared_count():count_(1){}
	void add_count(){
		count_++;
	}
	long reduce_count(){
		return --count_;
	}

	long get_count() const {
		return count_;
	}
private:
	long count_;
};


template<typename T>
class smart_ptr {
public:
	//模板的各个实例间并不天然就有 friend 关系，因而不能互访私有成员 ptr_ 和 shared_count_
	// 如果不加友元声明，则会报错：
	// error: 'circle* smart_ptr<circle>::ptr_' is private within this context
	// 即smart<shape>与smart<circle>两个实例不能互访对方的private成员
	template<typename U>
	friend class smart_ptr;

	explicit smart_ptr(T *ptr = nullptr):ptr_(ptr) {
		if(ptr)
			shared_count_ = new shared_count();
	}
	~smart_ptr(){
		//delete ptr_;
		if(ptr_ && shared_count_->reduce_count() == 0) {
			delete ptr_;
			delete shared_count_;
		}
	}

	// 实现强制类型转换而作的构造函数
	template<typename U>
	smart_ptr(const smart_ptr<U>& other, T *ptr) {
		ptr_ = ptr;
		if(ptr_) {
			other.shared_count_ -> add_count();
			shared_count_ = other.shared_count_;
		}
	}


	// 下面实现了泛化的版本，此处实现普通拷贝构造函数的原因是考虑以下规则：
	// 用户如果没有自己提供一个拷贝构造函数（必须形如 Obj(Obj&) 或 Obj(const Obj&)；不是模板），编译器会隐式声明一个。
	smart_ptr(const smart_ptr &other) {
		ptr_ = other.ptr_;
		if(ptr_) {
			other.shared_count_ -> add_count();
			shared_count_ = other.shared_count_;
		}
	}

	// 泛化版本的拷贝构造函数，用于子类向基类的转化
	// 不实现则没有能够用子类构造基类的操作符：
	// error: no match for 'operator=' (operand types are 'smart_ptr<shape>' and 'smart_ptr<circle>')

	template<typename U>
	smart_ptr(const smart_ptr<U> &other) {	
		// 虽然此处未检测T和U类型是否一致，但ptr_ = other.ptr_;的自动转换会判断管理的指针能否互相转化
		// 如int*不能直接赋值给一个double*，但是circle*可以赋值给shape*
		ptr_ = other.ptr_;	
		cout << "smart_ptr(const smart_ptr<U> &other)\n";
		if(ptr_) {
			other.shared_count_ -> add_count();
			shared_count_ = other.shared_count_;
		}
	}
	
	// 对于移动构造的情况，我们不需要调整引用数，直接把 other.ptr_ 置为空，认为 other 不再指向该共享对象
	template<typename U>
	smart_ptr(smart_ptr<U> &&other) {
		//ptr_ = other.release();
		ptr_ = other.ptr_;
		if(ptr_) {
			shared_count_ = other.shared_count_;
			other.ptr_ = nullptr; 	// 移动，计数不加，源指针置null
		}
	}

	
	smart_ptr& operator=(smart_ptr rhs) {	// 调用了构造函数，增加减少引用计数等操作都让构造函数干了
		rhs.swap(*this);	// rhs已经调用了构造函数创造副本
		return *this;
	}

	// 释放它对指针的所有权
	/*
	// 不再需要
	T* release() {
		T *ptr = ptr_;
		ptr_ = nullptr;
		return ptr;
	}*/

	long use_count() const {
		if(ptr_) {
			return shared_count_ -> get_count();
		} else return 0;
	}

	void swap(smart_ptr &rhs) {
		using std::swap;
		swap(ptr_, rhs.ptr_);
		swap(shared_count_, rhs.shared_count_);
	}

	T* get() const {return ptr_;}
	T& operator*() const {return *ptr_;}
	T* operator->() const {return ptr_;}
	operator bool() const {return ptr_;}
private:
	T* ptr_;
	shared_count* shared_count_;
};

// 将smart_ptr<U>转为smart_ptr<T>
template<typename T, typename U>
smart_ptr<T> dynamic_pointer_cast(const smart_ptr<U> &other) {
	T *ptr = dynamic_cast<T*>(other.get());
	return smart_ptr<T>(other, ptr);
}

int main() {
	// test
	smart_ptr<circle> ptr1(new circle()); 
	printf("use count of ptr1 is %ld\n", ptr1.use_count()); 
	smart_ptr<shape> ptr2; 
	printf("use count of ptr2 was %ld\n", ptr2.use_count()); 
	ptr2 = ptr1; 
	printf("use count of ptr2 is now %ld\n", ptr2.use_count()); 
	if (ptr1) { puts("ptr1 is not empty"); }

	smart_ptr<circle> ptr3 = dynamic_pointer_cast<circle>(ptr2);
	printf("use count of ptr3 is %ld\n", ptr3.use_count());	// 转型成功，计数为3
	return 0;
}

在这里插入图片描述

Reference

// 带有完整类型转换的shared_ptr版本
#include <utility>  // std::swap

class shared_count {
public:
  shared_count() noexcept
    : count_(1) {}
  void add_count() noexcept
  {
    ++count_;
  }
  long reduce_count() noexcept
  {
    return --count_;
  }
  long get_count() const noexcept
  {
    return count_;
  }

private:
  long count_;
};

template <typename T>
class smart_ptr {
public:
  template <typename U>
  friend class smart_ptr;

  explicit smart_ptr(T* ptr = nullptr)
    : ptr_(ptr)
  {
    if (ptr) {
      shared_count_ =
        new shared_count();
    }
  }
  ~smart_ptr()
  {
    if (ptr_ &&
      !shared_count_
         ->reduce_count()) {
      delete ptr_;
      delete shared_count_;
    }
  }

  smart_ptr(const smart_ptr& other)
  {
    ptr_ = other.ptr_;
    if (ptr_) {
      other.shared_count_
        ->add_count();
      shared_count_ =
        other.shared_count_;
    }
  }
  template <typename U>
  smart_ptr(const smart_ptr<U>& other) noexcept
  {
    ptr_ = other.ptr_;
    if (ptr_) {
      other.shared_count_->add_count();
      shared_count_ = other.shared_count_;
    }
  }
  template <typename U>
  smart_ptr(smart_ptr<U>&& other) noexcept
  {
    ptr_ = other.ptr_;
    if (ptr_) {
      shared_count_ =
        other.shared_count_;
      other.ptr_ = nullptr;
    }
  }
  template <typename U>
  smart_ptr(const smart_ptr<U>& other,
            T* ptr) noexcept
  {
    ptr_ = ptr;
    if (ptr_) {
      other.shared_count_
        ->add_count();
      shared_count_ =
        other.shared_count_;
    }
  }
  smart_ptr&
  operator=(smart_ptr rhs) noexcept
  {
    rhs.swap(*this);
    return *this;
  }

  T* get() const noexcept
  {
    return ptr_;
  }
  long use_count() const noexcept
  {
    if (ptr_) {
      return shared_count_
        ->get_count();
    } else {
      return 0;
    }
  }
  void swap(smart_ptr& rhs) noexcept
  {
    using std::swap;
    swap(ptr_, rhs.ptr_);
    swap(shared_count_,
         rhs.shared_count_);
  }

  T& operator*() const noexcept
  {
    return *ptr_;
  }
  T* operator->() const noexcept
  {
    return ptr_;
  }
  operator bool() const noexcept
  {
    return ptr_;
  }

private:
  T* ptr_;
  shared_count* shared_count_;
};

template <typename T>
void swap(smart_ptr<T>& lhs,
          smart_ptr<T>& rhs) noexcept
{
  lhs.swap(rhs);
}

template <typename T, typename U>
smart_ptr<T> static_pointer_cast(
  const smart_ptr<U>& other) noexcept
{
  T* ptr = static_cast<T*>(other.get());
  return smart_ptr<T>(other, ptr);
}

template <typename T, typename U>
smart_ptr<T> reinterpret_pointer_cast(
  const smart_ptr<U>& other) noexcept
{
  T* ptr = reinterpret_cast<T*>(other.get());
  return smart_ptr<T>(other, ptr);
}

template <typename T, typename U>
smart_ptr<T> const_pointer_cast(
  const smart_ptr<U>& other) noexcept
{
  T* ptr = const_cast<T*>(other.get());
  return smart_ptr<T>(other, ptr);
}

template <typename T, typename U>
smart_ptr<T> dynamic_pointer_cast(
  const smart_ptr<U>& other) noexcept
{
  T* ptr = dynamic_cast<T*>(other.get());
  return smart_ptr<T>(other, ptr);
}