C++学习之智能指针中的unique_ptr与shared_ptr

 

为什么需要智能指针

在上一讲《01 c++如何进行内存资源管理》中,提到了对于堆上的内存资源,需要我们手动分配和释放。管理这些资源是个技术活,一不小心,就会导致内存泄漏。

我们再给两段代码,切身体验下原生指针管理内存的噩梦。

void foo(int n) {
  int* ptr = new int(42);
  ...
  if (n > 5) {
	    return;
  }
  ...
  delete ptr;
}
void other_fn(int* ptr) {
	...
};
void bar() {
  int* ptr = new int(42);
  other_fn(ptr);
  // ptr == ?
}

在foo函数中,如果入参n> 5, 则会导致指针ptr的内存未被正确释放,从而导致内存泄漏。

在bar函数中,我们将指针ptr传递给了另外一个函数other_fn,我们无法确定other_fn有没有释放ptr内存,如果被释放了,那ptr将成为一个悬空指针,bar在后续还继续访问它,会引发未定义行为,可能导致程序崩溃。

上面由于原生指针使用不当导致的内存泄漏、悬空指针问题都可以通过智能指针来轻松避免。

c++智能指针是一种用于管理动态分配内存的指针类。基于raii设计理念,通过封装原生指针实现的。可以在资源(原生指针对应的对象)生命周期结束时自动释放内存。

c++标准库中,提供了两种最常见的智能指针类型,分别是std::unique_ptr和std::shared_ptr。
接下来我们分别详细展开介绍。

 

吃独食的unique_ptr

std::unique_ptr是 c++11 引入的智能指针,用于管理动态分配的内存。每个std::unique_ptr实例都拥有对其所包含对象的唯一所有权,并在其生命周期结束时自动释放对象。

创建unique_ptr对象

我们可以std::unique_ptr的构造函数或std::make_unique函数(c++14支持)来创建一个unique_ptr对象,在超出作用域时,会自动释放所管理的对象内存。示例代码如下:

#include  #include  class myclass {
public:
  myclass() {
      std::cout << "myclass constructed" << std::endl;
  }
  ~myclass() {
      std::cout << "myclass destroyed" << std::endl;
  }
};
int main() {
	std::unique_ptr ptr1(new myclass);
	// c++14开始支持std::make_unique
  std::unique_ptr ptr2 = std::make_unique(10);
  return 0;
}

代码输出:

myclass constructed
myclass destroyed

访问所管理的对象

我们可以像使用原生指针的方式一样,访问unique_ptr所指向的对象。也可以通过get函数获取到原生指针。

myclass* naked_ptr = ptr1.get();
std::cout << *ptr2 << std::endl; // 输出 10

释放/重置所管理的对象

使用reset函数可以释放unique_ptr所管理的对象,并将其指针重置为nullptr或指定的新指针。reset`大概实现原理如下

template 
void unique_ptr::reset(pointer ptr = pointer()) noexcept { 
	// 释放指针指向的对象
	delete ptr_; 
	// 重置指针
	ptr_ = ptr;
}

该函数主要完成两件事:

  • 释放std::unique_ptr所管理的对象,以避免内存泄漏。
  • 将std::unique_ptr重置为nullptr或管理另一个对象。

code show time:

#include  #include  class myclass {
public:
  myclass() {
      std::cout << "myclass constructed" << std::endl;
  }
  ~myclass() {
      std::cout << "myclass destroyed" << std::endl;
  }
};
int main() {
  // 创建一个 std::unique_ptr 对象,指向一个 myclass 对象
  std::unique_ptr ptr(new myclass);
  // 调用 reset,将 std::unique_ptr 重置为管理另一个 myclass 对象
  ptr.reset(new myclass);
  return;
}

移动所有权

一个对象资源只能同时被一个unique_ptr管理。当尝试把一个unique_ptr直接赋值给另外一个unique_ptr会编译报错。

#include  int main() {
  std::unique_ptr p1 = std::make_unique(42);
  std::unique_ptr p2 = p1; // 编译报错
  return 0;
}

为了把一个std::unique_ptr对象的所有权移动到另一个对象中,我们必须配合std::move移动函数。

#include  #include  int main() {
  std::unique_ptr p1 = std::make_unique(42);
  std::unique_ptr p2 = std::move(p1); // ok
  std::cout << *p2 << std::endl; // 42
  std::cout << (p1.get() == nullptr) << std::endl; // true
  return 0;
}

这个例子中, 我们把p1通过std::move将其管理对象的所有权转移给了p2, 此时p2接管了对象,而p1不再拥有管理对象的所有权,即无法再操作到该对象了。

 

乐于分享的shared_ptr

shared_ptr是c++11提供的另外一种常见的智能指针,与unique_ptr独占对象方式不同,shared_ptr是一种共享式智能指针,允许多个shared_ptr指针共同拥有同一个对象,采用引用计数的方式来管理对象的生命周期。当所有的shared_ptr对象都销毁时,才会自动释放所管理的对象。

创建shared_ptr对象

同样的,c++也提供了std::shared_ptr构造函数和std::make_shared函数来创建std::shared_ptr对象。

#include  int main() {
	std::shared_ptr p1(new int(10));
	std::shared_ptr p2 = std::make_shared(20);
	return;
}

多个shared_ptr共享一个对象

可以通过赋值操作实现多个shared_ptr共享一个资源对象,例如

std::shared_ptrp3 = p2;

shared_ptr采用引用计数的方式管理资源对象的生命周期,通过分配一个额外内存当计数器。

当一个新的shared_ptr被创建时,它对应的计数器被初始化为1。每当赋值给另外一个shared_ptr共享同一个对象时,计数器值会加1。当某个shared_ptr被销毁时,计数值会减1,当计数值变为0时,说明没有任何shared_ptr引用这个对象,会将对象进行回收。

c++提供了use_count函数来获取std::shared_ptr所管理对象的引用计数,例如

std::cout << "p1 use count: " << p1.use_count() << std::endl;

释放/重置所管理的对象

可以使用reset函数来释放/重置shared_ptr所管理的对象。大概实现原理如下(不考虑并发场景)

void reset(t* ptr = nullptr) {
	if (ref_count != nullptr) { 
		(*ref_count)--;
		if (*ref_count == 0) { 
			delete data; 
			delete ref_count; 
		} 
	} 
	data = ptr; 
	ref_count = (data == nullptr) ? nullptr : new size_t(1); 
}

data指针来存储管理的资源,指针ref_count来存储计数器的值。

在 reset 方法中,需要减少计数器的值,如果计数器减少后为 0,则需要释放管理的资源,如果减少后不为0,则不会释放之前的资源对象。

如果reset指定了新的资源指针,则需要重新设置 data 和 ref_count,并将计数器初始化为 1。否则,将计数器指针置为nullptr

shared_ptr使用注意事项

避免循环引用

由于shared_ptr具有共享同一个资源对象的能力,因此容易出现循环引用的情况。例如:

struct node { 
	std::shared_ptr next; 
};
int main() {
	std::shared_ptr node1(new node);
	std::shared_ptr node2(new node); 
	node1->next = node2; 
	node2->next = node1;
}

在上述代码中,node1和node2互相引用,在析构时会发现计数器的值不为0,不会释放所管理的对象,产生内存泄漏。

为了避免循环引用,可以将其中一个指针改为weak_ptr类型。weak_ptr也是一种智能指针,通常配合shared_ptr一起使用。

weak_ptr是一种弱引用,不对所指向的对象进行计数引用,也就是说,不增加所指对象的引用计数。当所有的shared_ptr都析构了,不再指向该资源时,该资源会被销毁,同时对应的所有weak_ptr都会变成nullptr,这时我们就可以利用expired()方法来判断这个weak_ptr是否已经失效。

我们可以通过weak_ptr的lock()方法来获得一个指向共享对象的shared_ptr。如果weak_ptr已经失效,lock()方法将返回一个空的shared_ptr。

下面是weak_ptr的基本使用示例:

#include  #include  int main() {
  std::shared_ptr sp = std::make_shared(42);
  // 创建shared_ptr对应的weak_ptr指针
  std::weak_ptr wp(sp);
	// 通过lock创建一个对应的shared_ptr
  if (auto p = wp.lock()) {
      std::cout << "shared_ptr value: " << *p << std::endl;
      std::cout << "shared_ptr use_count: " << p.use_count() << std::endl;
  } else {
      std::cout << "wp is expired" << std::endl;
  }
	// 释放shared_ptr指向的资源,此时weak_ptr失效
  sp.reset();
  std::cout << "wp is expired: " <<  wp.expired() << std::endl;
  return 0;
}

代码输出如下

shared_ptr value: 42
shared_ptr use_count: 2
wp is expired: 1

回到shared_ptr的循环引用问题,利用weak_ptr不会增加shared_ptr的引用计数的特点,我们将node.next的类型改为weak_ptr, 避免node1和node2互相循环引用。修改后代码如下

```cpp
struct node { 
	std::weak_ptr next; 
};
int main() {
	std::shared_ptr node1(new node);
	std::shared_ptr node2(new node); 
	node1->next = std::weak_ptr(node2); 
	node2->next = std::weak_ptr(node1); ;
}

避免裸指针与shared_ptr混用

先看看以下代码

int* q = new int(9);
{
	std::shared_ptr p(new int(10));
	...
	q = p.get();
}
std::cout << *q << std::endl;

get函数返回std::shared_ptr所持有的指针,但是不会增加引用计数。所以在shared_ptr析构时,将该指针指向的对象给释放掉了,导致指针q变成一个悬空指针。

避免一个原始指针初始化多个shared_ptr

int* p = new int(10);
std::shared_ptr ptr1(p);
// error: 两个shared_ptr指向同一个资源,会导致重复释放
std::shared_ptr ptr2(p);

 

总结

避免手动管理内存带来的繁琐和容易出错的问题。我们今天介绍了三种智能指针:unique_ptr、shared_ptr和weak_ptr。
每种智能指针都有各自的使用场景。unique_ptr用于管理独占式所有权的对象,它不能拷贝但可以移动,是最轻量级和最快的智能指针。shared_ptr用于管理多个对象共享所有权的情况,它可以拷贝和移动。weak_ptr则是用来解决shared_ptr循环引用的问题。

相关文章