智能指针

关注

转载最新推荐文章于 2026-09-06 13:49:57 发布 722 阅读 AI 写同款· GEO 优化 ›

【C++】————智能指针 在C++中没有垃圾回收机制，必须自己释放分配的内存，否则就会造成内存泄露。解决这个问题最有效的方法是使用智能指针（smart pointer）。智能指针是存储指向动态分配（堆）对象指针的类，用于生存期的控制，能够确保在离开指针所在作用域时，自动地销毁动态分配的对象，防止内存泄露。智能指针的核心实现技术是引用计数，每使用它一次，内部引用计数加1，每析构一次内部的引用计数减1，减为0时，删除所指向的堆内存。c++中用的最多的是下面三种智能指针。阅读详情

Boost中提供的5类智能指针。分别是：

l scoped_ptr 独占的指针

l scoped_array 独占的数组

l shared_ptr 引用计数指针

l shared_array 引用计数数组

l weak_ptr shared_ptr的一个弱指针（不参与引用计数）

l intrusive_ptr 自定义的引用计数指针

scoped_ptr和scoped_array

对于scoped_ptr和scoped_array是不可以拷贝构造和赋值的（拷贝构造函数和operator=都是私有成员）。所以它们不像auto_ptr那样传递指针的拥有权，而是独占拥有权，直至对象的销毁（当scoped_ptr和scropted_array析构的时候，所指向的对象也会被析构）。

构造：

scoped_ptr<int> a(new int);

scoped_ptr<int> b;

scoped_array<int> c(new int[100]);

scoped_array<int> d;

scoped_ptr使用new T或者是NULL来初始化对象。scoped_array使用new T[]或者NULL来初始化对象。

它们的默认构造函数，是使用NULL来初始化。

访问：

scoped_ptr重载了operator*和operator->操作符，而scoped_array重载了operator[]下标运算符。通过这几个操作符来操作它们所指向的对象。它们都可以通过T* get()成员函数得到原始的指针。

例如：

scoped_array<char> str(newchar[100]);

strcpy(str.get(),"hello");

cout<<str[0]<<str[4]<<endl;//输出ho

void reset(T * p = 0)

reset用于重置指针指向的对象，当调用reset的时候scoped_ptr或scoped_array会先删除原来指向的对象（如果不是指向NULL的话）。reset的参数和它们构造函数的要求是一样的，必须是new T（或new T[]）或者是NULL。

swap

swap全局函数和swap成员函数，交换两个智能指针指向的对象。例如：

scoped_ptr<int> a(new int);//a指向一个int

scoped_ptr<int> b;//b指向NULL

swap(a,b);//这时，a指向NULL，b指向一个int

bool

scoped_ptr和scoped_array可以隐式的转换为bool类型，当指向NULL的时候返回false，否则返回true。

类型

scoped_ptr<T>和scoped_array<T>中的类型T不能是void类型。

并且scoped_ptr<T>和scoped_ptr<U>不存在类型转换，即使T和U是可以转换的，scoped_ptr<T>和scoped_ptr<const T>也不能转换。

shared_ptr和shared_array

shared_ptr和shared_array是引用计数的智能指针。

下面仅仅介绍shared_ptr的使用。

构造：

对于shared_ptr<T>来说一共有6个构造函数：

shared_ptr(Y * p);

最普通的构造函数，p一定是一个new Y的指针或NULL。注意这里p的类型是Y*，而不是shared_ptr<T>中的T*，所以p一定要存在一个到T*的类型转换。同时shared_ptr会记住p的类型是Y，当p所指向的对象要被析构的时候，shared_ptr会使用正确的析构函数（Y类型的析构函数，而不是T类型的析构函数）。例如：

struct A

{

A(){cout<<"A construct"<<endl;}

~A(){cout<<"A destory"<<endl;}

};

int main()

{

shared_ptr<void> a(new A);

return 0;

}

程序输出：

A construct

A destroy

这就说明A被正确的析构的，并不因为shared_ptr<void>的void而不能析构A，例如：

voiddel(void *p){delete p;}这就是错的

shared_ptr(Y * p,D d);

同上。d是一个仿函数，用来析构p的，例如：

template <class T>

void my_delete(T * p)

{

delete p;

}

int main()

{

shared_ptr<void> a(new A,my_delete<A>);

return 0;

}

shared_ptr(shared_ptr<Y> const & r);

拷贝构造函数，注意也存在类型转换哦。

shared_ptr(weak_ptr<Y> const & r);

虽然weak_ptr不参与引用计数，但是shared_ptr会的。

shared_ptr(std::auto_ptr<Y> & r);

这时r就指向NULL了。

重置reset：

void reset();

void reset(Y * p);

void reset(Y * p,D d);

shared_ptr<T> & perator=(shared_ptr<T> const & r);

shared_ptr<T> & perator=(shared_ptr<Y> const & r);

shared_ptr<T> & perator=(std::auto_ptr<Y> & r);

使原来shared_ptr指向的对象引用计数减一，并指向另一个对象，类似于重新构造，所以它们的参数和构造函数一样。

引用计数成员函数：

long use_count();返回引用计数

bool unique();返回use_count()==1

其它：

bool类型转换，operator==，operator!=，operator<，swap，get，流输出（输出指针地址）

D* get_deleter()得到deleter，用来析构对象的仿函数指针。

类型转换：

shared_ptr<T> static_pointer_cast<T>(shared_ptr<U> const & r);

shared_ptr<T> const_pointer_cast<T>(shared_ptr<U> const & r);

shared_ptr<T> dynamic_pointer_cast<T>(shared_ptr<U> const & r);

以上是类似于c++类型转换的一些函数。由于shared_ptr支持指针的类型转换，所以shared_ptr可以保存void指针，也可以向基类指针的转换。这点，scoped_ptr就不可以！

Weak_ptr

weak_ptr是对shared_ptr的一个访问者，weak_ptr不参与shared_ptr的引用计数，也不会删除所指向的对象。同时，当对象被shared_ptr删除后，weak_ptr就是无效的了。

使用weak_ptr，而不使用T*这样的c++指针的原因是：weak_ptr是可以转换成shared_ptr参与引用计数，而T*不可以（只有new T出来的指针才可以构造shared_ptr）。也就是说，weak_ptr虽然不参与引用计数，但是引用计数这套机制还是存在的，当需要转换成shared_ptr的时候就把这套机制传给shared_ptr。否则的话，使用T*构造shared_ptr的话，相当于有两套机制来管理引用计数，那么一个shared_ptr可能指向无效的对象（对象被另一套引用计数机制删除了）。