C++中智能指针的实现原理

智能指针:它的一种通用实现方法是采用引用计数的方法。智能指针将一个计数器与类指向的对象相关联,引用计数跟踪共有多少个类对象共享同一指针。


每次创建类的新对象时,初始化指针并将引用计数置为1;
当对象作为另一对象的副本而创建时,拷贝构造函数拷贝指针并增加与之相应的引用计数;
对一个对象进行赋值时,赋值操作符减少左操作数所指对象的引用计数(如果引用计数为减至0,则删除对象),并增加右操作数所指对象的引用计数;这是因此左侧的指针指向了右侧指针所指向的对象,因此右指针所指向的对象的引用计数+1;
调用析构函数时,构造函数减少引用计数(如果引用计数减至0,则删除基础对象)。
实现智能指针有两种经典策略:一是引入辅助类,二是使用句柄类。这里主要讲一下引入辅助类的方法,看下面的例子:


class Point                                       //基础对象类,要做一个对Point类的智能指针
{
public:
    Point(int xVal = 0, int yVal = 0):x(xVal),y(yVal) { }
    int getX() const { return x; }
    int getY() const { return y; }
    void setX(int xVal) { x = xVal; }
    void setY(int yVal) { y = yVal; }
private:
    int x,y;
};
class RefPtr                                  //辅助类
{//该类成员访问权限全部为private,因为不想让用户直接使用该类
 friend class SmartPtr;      //定义智能指针类为友元,因为智能指针类需要直接操纵辅助类
 RefPtr(Point *ptr):p(ptr), count(1) { }
 ~RefPtr() { delete p; }
  
 int count;                                                     //引用计数
 Point *p;                                                      //基础对象指针
};
  
class SmartPtr                                             //智能指针类
{
public:
 SmartPtr(Point *ptr):rp(new RefPtr(ptr)) { }                                 //构造函数
 SmartPtr(const SmartPtr &sp):rp(sp.rp) { ++rp->count; }            //复制构造函数
 SmartPtr& operator=(const SmartPtr& rhs) {                              //重载赋值操作符
  ++rhs.rp->count;                                                         //首先将右操作数引用计数加1,
  if(--rp->count == 0)                                                                     //然后将引用计数减1,可以应对自赋值
   delete rp;
  rp = rhs.rp;
  return *this;
 }
 ~SmartPtr() {                                            //析构函数
  if(--rp->count == 0)                                  //当引用计数减为0时,删除辅助类对象指针,从而删除基础对象
   delete rp;
 }
  
private:
 RefPtr *rp;                                                //辅助类对象指针
};
  
int main()
{
 Point *p1 = new Point(10, 8);
 SmartPtr sp1(p1);    //此时sp1.rp->count = 1
 SmartPtr sp2(sp1);    //首先将sp1.rp->count赋给sp2.rp->count,之后sp2.rp->count++,这时sp1,sp2的rp是同一个对象
 Point *p2 = new Point(5, 5);
 SmartPtr sp3(p2);
 sp3 = sp1;
  
 return 0;
}
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
智能指针是一种用于自动管理动态分配内存的工具。其最常见的智能指针C++的std::shared_ptr和std::unique_ptr。下面是一个简单实现智能指针的示例: ```c++ #include <iostream> template <typename T> class SmartPointer { public: SmartPointer(T* ptr) : ptr_(ptr), ref_count_(new size_t(1)) { } SmartPointer(const SmartPointer<T>& other) : ptr_(other.ptr_), ref_count_(other.ref_count_) { ++(*ref_count_); } ~SmartPointer() { if (--(*ref_count_) == 0) { delete ptr_; delete ref_count_; } } SmartPointer<T>& operator=(const SmartPointer<T>& other) { if (this != &other) { if (--(*ref_count_) == 0) { delete ptr_; delete ref_count_; } ptr_ = other.ptr_; ref_count_ = other.ref_count_; ++(*ref_count_); } return *this; } T& operator*() const { return *ptr_; } T* operator->() const { return ptr_; } private: T* ptr_; size_t* ref_count_; }; int main() { SmartPointer<int> sp1(new int(5)); std::cout << *sp1 << std::endl; SmartPointer<int> sp2 = sp1; std::cout << *sp2 << std::endl; sp1 = SmartPointer<int>(new int(10)); std::cout << *sp1 << std::endl; std::cout << *sp2 << std::endl; return 0; } ``` 在上面的例子,我们定义了一个模板类 SmartPointer,它保存了一个指向动态分配内存的原始指针 ptr_,以及一个引用计数 ref_count_。构造函数,我们将引用计数初始化为1。当拷贝构造一个智能指针时,我们增加引用计数。当析构一个智能指针时,我们减少引用计数,并在引用计数变为0时释放内存。赋值运算符重载,我们首先减少旧指针的引用计数,然后增加新指针的引用计数。 这只是一个简单的智能指针实现示例,实际上,标准库的std::shared_ptr和std::unique_ptr提供了更多的功能和安全性保证。但是这个实现可以帮助你理解智能指针的基本原理。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值