C++智能指针学习——小谈引用计数

最新推荐文章于 2024-05-19 12:01:11 发布
最新推荐文章于 2024-05-19 12:01:11 发布
阅读量920 收藏 18
点赞数 13
分类专栏： C++ 文章标签： c++ 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44727495/article/details/137260903
版权

C++智能指针学习——小谈引用计数

前言

本文结合源码讨论std::shared_ptr和std::weak_ptr的部分底层实现，然后讨论引用计数，弱引用计数的创建和增减。
文章中尽可能的先阐述原理，然后再贴上代码。如果有不想看代码的，直接略过代码即可。
本文涉及的源码均出自gcc 9.4.0版本

控制块简介

控制块是shared_ptr和weak_ptr中的重要组成，主要用于管理资源的引用计数和生命周期。这个机制允许智能指针安全地共享和管理同一个对象，同时自动释放不再需要的资源。

控制块包含以下部分：

  • 引用计数
  • 弱引用计数
  • 分配器
  • 删除器

本文讨论的引用计数和弱引用计数的创建、加减、销毁，与控制块密切相关。

共享控制块

首先我们要知道，当创建一个std::shared_ptr指向某个对象时，会生成一个控制块来存储该对象的引用计数和其他管理信息。如果基于这个std::shared_ptr再创建一个或多个std::weak_ptr，那么这些std::weak_ptr将也指向这个控制块。

示意图大概长这样：
在这里插入图片描述

引用计数与弱引用计数创建过程

在谈引用计数和弱引用计数的创建时，其实就是讨论控制块的创建。

我们知道std::weak_ptr是被设计用来解决std::shared_ptr智能指针可能导致的循环引用问题。一个有效的std::weak_ptr对象一般是通过std::shared_ptr构造的或者是通过拷贝（移动）其他std::weak_ptr对象得到的，std::weak_ptr对象的构造不涉及控制块的创建。

因此在讨论引用计数、弱引用计数的创建时，我们是去分析std::shared_ptr的源码

__shared_ptr

__shared_ptr是std::shared_ptr的核心实现，它位于shared_ptr_base.h中。

__shared_ptr在构造实例时都会构造一个_M_refcount，它的类型为__shared_count<_Lp>。

//file: shared_ptr_base.h
template<typename _Tp, _Lock_policy _Lp>
class __shared_ptr : public __shared_ptr_access<_Tp, _Lp>
{
public:
	using element_type = typename remove_extent<_Tp>::type;
	//默认构造
	constexpr __shared_ptr() noexcept
      : _M_ptr(0), _M_refcount()
      { }
	...	
	//有删除器和分配器的构造
	template<typename _Yp, typename _Deleter, typename _Alloc,
	       typename = _SafeConv<_Yp>>
	__shared_ptr(_Yp* __p, _Deleter __d, _Alloc __a)
	: _M_ptr(__p), _M_refcount(__p, std::move(__d), std::move(__a))
	{
	  static_assert(__is_invocable<_Deleter&, _Yp*&>::value,
	      "deleter expression d(p) is well-formed");
	  _M_enable_shared_from_this_with(__p);
	}
private:
	...
	element_type*        _M_ptr;         // Contained pointer.
    __shared_count<_Lp>  _M_refcount;    // Reference counter.	
};

__shared_count

在创建__shared_count对象时，也会创建一个指向控制块的指针（_Sp_counted_base类型的指针）。控制块用来管理引用计数。

代码中的_Sp_counted_ptr和_Sp_counted_deleter就是_Sp_counted_base的派生类。

//file: shared_ptr_base.h
template<_Lock_policy _Lp>
class __shared_count
{
public:
	//默认构造
	__shared_count(_Ptr __p) : _M_pi(0)
	{
	  __try
	    {
	      _M_pi = new _Sp_counted_ptr<_Ptr, _Lp>(__p);
	    }
	  __catch(...)
	    {
	      delete __p;
	      __throw_exception_again;
	    }
	}
	//带分配器和删除器的构造
	template<typename _Ptr, typename _Deleter, typename _Alloc,
	       typename = typename __not_alloc_shared_tag<_Deleter>::type>
	__shared_count(_Ptr __p, _Deleter __d, _Alloc __a) : _M_pi(0)
	{
	  	typedef _Sp_counted_deleter<_Ptr, _Deleter, _Alloc, _Lp> _Sp_cd_type;
		__try
	    {
	      	typename _Sp_cd_type::__allocator_type __a2(__a);
	      	auto __guard = std::__allocate_guarded(__a2);
	      	_Sp_cd_type* __mem = __guard.get();
	      	::new (__mem) _Sp_cd_type(__p, std::move(__d), std::move(__a));
	      	_M_pi = __mem;
	      	__guard = nullptr;
	    }
	  	__catch(...)
	    {
	      	__d(__p); // Call _Deleter on __p.
	      	__throw_exception_again;
	    }
	}
private:
	friend class __weak_count<_Lp>;
	_Sp_counted_base<_Lp>*  _M_pi;
};

_Sp_counted_base

_Sp_counted_base负责管理引用计数和弱引用计数，其中

  • _M_use_count是shared_ptr的计数，就是引用计数，表示有多少个shared_ptr对象共享同一个内存资源。
  • _M_weak_count是weak_ptr的计数，也就是弱引用计数，表示有多少个weak_ptr对象引用同一个资源。

我们可以看到在_Sp_counted_base的初始化列表中，初始化了_M_use_count和_M_weak_count为1，完成了引用计数和弱引用计数的创建和初始化。

//file: shared_ptr_base.h
template<_Lock_policy _Lp = __default_lock_policy>
class _Sp_counted_base : public _Mutex_base<_Lp>
{
public:
	_Sp_counted_base() noexcept : _M_use_count(1), _M_weak_count(1) { }
	...	
private:
	_Atomic_word  _M_use_count;     // #shared
	_Atomic_word  _M_weak_count;    // #weak + (#shared != 0)
};

这里再简单提一下_Sp_counted_base、_Sp_counted_ptr和_Sp_counted_deleter的关系与各自的功能。

  • _Sp_counted_base是一个抽象基类，定义并管理了引用计数与弱引用记数。
  • _Sp_counted_ptr继承自_Sp_counted_base，主要是使用默认的分配策略和删除策略管理资源对象。
  • _Sp_counted_deleter继承自_Sp_counted_base，主要是使用用户提供的分配器和删除器管理资源对象。

因为_Sp_counted_base是抽象基类无法被实例化，所以使用的是其派生类_Sp_counted_ptr和_Sp_counted_deleter对象来管理引用计数、弱引用计数、分配器、删除器。这个对象就是我们常说的控制块。

（_Sp_counted_base还有一个派生类_Sp_counted_ptr_inplace，适合使用std::make_shared的场景，此处不过多讨论）

弱引用计数增加过程

再谈共享控制块

在上面的引用计数与弱引用计数创建过程中，我们提到：

一个有效的std::weak_ptr对象一般是通过std::shared_ptr构造的或者是通过拷贝（移动）其他std::weak_ptr对象得到的

对应的__weak_count和__shared_count对象也具有上述关系。

查看源码，我们可以发现，__weak_count和__shared_count都有一个指向控制块的多态指针。

	_Sp_counted_base<_Lp>*  _M_pi;

在__weak_count中并没有使用new或者类似操作让_M_pi指向一块新的内存（控制块）。追根溯源，__weak_count中多态指针指向的控制块的来源就是__shared_count。代码中是通过在__weak_count构造函数和重载的赋值运算符中给多态指针_M_pi初始化和赋值实现的。以此实现了weak_ptr和shared_ptr共享控制块的功能。

__weak_count

弱引用计数的增加可以分为下面几种情况:

  • 通过std::shared_ptr构造std::weak_ptr
  • 通过std::weak_ptr构造std::weak_ptr
  • 通过std::shared_ptr给std::weak_ptr赋值
  • 通过std::weak_ptr给std::weak_ptr赋值

其实本质是靠调用_M_weak_add_ref()增加的弱引用计数，详情见__weak_count的源码：

//file: shared_ptr_base.h
template<_Lock_policy _Lp>
class __weak_count
{
public:
	...
	//通过__shared_count构造
    //和一个已存在的__shared_count对象共享控制块，并更新控制块的弱引用计数
    __weak_count(const __shared_count<_Lp>& __r) noexcept
     : _M_pi(__r._M_pi)
    {
    	//若入参的多态指针不为空
        //弱引用计数++（增加_Sp_counted_base对象的_M_weak_count）
		if (_M_pi != nullptr)
			_M_pi->_M_weak_add_ref();
	}
	
	//通过__weak_count拷贝构造
    //和传入的__weak_count对象就共享同一个控制块，并更新控制块的弱引用计数
    __weak_count(const __weak_count& __r) noexcept
     : _M_pi(__r._M_pi)
    {
		if (_M_pi != nullptr)
			_M_pi->_M_weak_add_ref();
    }
    
	//通过__shared_count给__weak_count赋值
	__weak_count& operator=(const __shared_count<_Lp>& __r) noexcept
    {
    	_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
    	//新对象弱引用计数++
		if (__tmp != nullptr)
	  		__tmp->_M_weak_add_ref();
	  	//原对象弱引用计数--
		if (_M_pi != nullptr)
	  		_M_pi->_M_weak_release();
	  	//指向新对象的控制块
		_M_pi = __tmp;
		return *this;
	}

	//通过__weak_count给__weak_count赋值
	__weak_count& operator=(const __weak_count& __r) noexcept
    {
		_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
		if (__tmp != nullptr)
	  		__tmp->_M_weak_add_ref();
		if (_M_pi != nullptr)
	  		_M_pi->_M_weak_release();
		_M_pi = __tmp;
		return *this;
      }
    ...
private:
	friend class __shared_count<_Lp>;
	_Sp_counted_base<_Lp>*  _M_pi;
};

引用计数增加过程

引用计数的增加可以分为下面几种情况:

  • 通过std::shared_ptr构造std::shared_ptr
  • 通过std::shared_ptr给std::shared_ptr赋值
  • std::weak_ptr升级为std::shared_ptr

本质是靠调用_M_add_ref_copy()和_M_add_ref_lock增加的引用计数，详情见__shared_count的源码：

//file: shared_ptr_base.h
template<_Lock_policy _Lp>
class __shared_count
{
public:
	//拷贝构造
    __shared_count(const __shared_count& __r) noexcept
     : _M_pi(__r._M_pi)
    {
		if (_M_pi != 0)
			_M_pi->_M_add_ref_copy();
    }

	//拷贝赋值
	__shared_count& operator=(const __shared_count& __r) noexcept
    {
		_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
		if (__tmp != _M_pi)
	  	{
	    	if (__tmp != 0)
	      		__tmp->_M_add_ref_copy();
	    	if (_M_pi != 0)
	      		_M_pi->_M_release();
	    	_M_pi = __tmp;
	    }
		return *this;
	}
	
	//转换构造
	//weak_ptr使用lock()时会调用此构造函数
	explicit __shared_count(const __weak_count<_Lp>& __r) 
	 : _M_pi(__r._M_pi)
    {
    	if (_M_pi != nullptr)
			_M_pi->_M_add_ref_lock();//引用计数++，具体实现依赖于锁策略
      	else
			__throw_bad_weak_ptr();
    }
private:
	friend class __weak_count<_Lp>;
	_Sp_counted_base<_Lp>*  _M_pi;
};

弱引用计数的减少过程

弱引用计数的减少可以分为下面几种情况:

  • std::weak_ptr析构
  • std::weak_ptr对象被覆盖（赋值操作覆盖原std::weak_ptr）

本质是靠调用_M_weak_release()减少弱引用计数：

//file: shared_ptr_base.h
template<_Lock_policy _Lp>
class __weak_count
{
public:
	//析构
	~__weak_count() noexcept
    {
      if (_M_pi != nullptr)
        _M_pi->_M_weak_release();
    }
	//转换赋值
	__weak_count& operator=(const __shared_count<_Lp>& __r) noexcept
	{
    	_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
        if (__tmp != nullptr)
          	__tmp->_M_weak_add_ref();
        if (_M_pi != nullptr)
        	_M_pi->_M_weak_release();
        _M_pi = __tmp;
	    return *this;
	}
	//拷贝赋值
	__weak_count& operator=(const __weak_count& __r) noexcept
	{
      	_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
        if (__tmp != nullptr)
          	__tmp->_M_weak_add_ref();
        if (_M_pi != nullptr)
          	_M_pi->_M_weak_release();
        _M_pi = __tmp;
    	return *this;
    }
    //移动赋值
    __weak_count& operator=(__weak_count&& __r) noexcept
    {
    	if (_M_pi != nullptr)
        	_M_pi->_M_weak_release();
      	_M_pi = __r._M_pi;
            __r._M_pi = nullptr;
      	return *this;
    }

private:
	friend class __shared_count<_Lp>;
	_Sp_counted_base<_Lp>*  _M_pi;
};

然后在这里对std::weak_ptr::reset()说明一下：它是用来重置 std::weak_ptr 的。调用 reset() 会使std::weak_ptr不再指向它原本观察的对象。

它也会减少原对象的弱引用计数（本质是通过调用的析构函数使得弱引用计数减少）

//file: shared_ptr_base.h
void reset() noexcept
{ 
	__weak_ptr().swap(*this); 
}

弱引用计数减为0

在上面提到：弱引用计数的减少是通过调用_M_weak_release()实现的。通过分析_M_weak_release()的代码我们可以知道，_M_weak_release()中主要做了：

  • 对弱引用计数做减1操作并
  • 判断弱引用计数减1后是否为0，若为0则调用_M_destroy()删除控制块。
//file: shared_ptr_base.h
template<_Lock_policy _Lp = __default_lock_policy>
class _Sp_counted_base : public _Mutex_base<_Lp>
{
    //控制块的弱引用计数为0时，销毁自身
    virtual void _M_destroy() noexcept
    { delete this; }
    
    //弱引用计数--
    //当弱引用计数变为0，销毁控制块
	void _M_weak_release() noexcept
    {
    	// Be race-detector-friendly. For more info see bits/c++config.
        _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count);
        //减少弱引用计数，并返回-1之前的值
	    if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, -1) == 1)
	    {
        	_GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count);
	        if (_Mutex_base<_Lp>::_S_need_barriers)
	        {
	        // See _M_release(),
	        // destroy() must observe results of dispose()
		    	__atomic_thread_fence (__ATOMIC_ACQ_REL);
	        }
	        _M_destroy();
	    }
    }
};

引用计数的减少过程

引用计数的减少可以分为下面几种情况:

  • std::shared_ptr析构
  • std::shared_ptr对象被覆盖（赋值操作覆盖原std::shared_ptr）

本质是靠调用_M_release()减少弱引用计数

//file: shared_ptr_base.h
template<_Lock_policy _Lp>
class __shared_count
{
public:
	//析构
	~__shared_count() noexcept
	{
        if (_M_pi != nullptr)
        	_M_pi->_M_release();
    }
    //拷贝赋值
    __shared_count& operator=(const __shared_count& __r) noexcept
    {
		_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
        if (__tmp != _M_pi)
        {
          	if (__tmp != 0)
            	__tmp->_M_add_ref_copy();
          	if (_M_pi != 0)
            	_M_pi->_M_release();
          	_M_pi = __tmp;
        }
	    return *this;
	}
private:
	friend class __weak_count<_Lp>;
	_Sp_counted_base<_Lp>*  _M_pi;
};

引用计数减为0

上面提到：引用计数的减少是通过调用_M_release()实现的。通过分析_M_release()的代码我们可以知道，_M_release()中主要做了

  • 对引用计数做减1操作并
  • 判断引用计数减1后是否为0，若为0则调用_M_dispose()释放其所管理的内存资源
  • 若引用计数减1后为0，则还会对弱引用计数做一次减1操作并
  • 判断弱引用计数减1后是否为0，若为0则调用_M_destroy()删除控制块。
//file: shared_ptr_base.h
template<_Lock_policy _Lp = __default_lock_policy>
class _Sp_counted_base : public _Mutex_base<_Lp>
{
	//当前对象的引用计数为0时，释放管理的资源
    //纯虚函数，取决于释放策略，由派生类实现
    virtual void _M_dispose() noexcept = 0;

    //当前对象的弱引用计数为0时，销毁自身
    virtual void _M_destroy() noexcept
    { delete this; }
	
	void _M_release() noexcept
    {
    	// Be race-detector-friendly.  For more info see bits/c++config.
        _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_use_count);
        //减少引用计数，并返回-1之前的值
        //如果引用计数为0，则释放管理的资源
	    if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1)
	    {
        	_GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_use_count);
	        _M_dispose();
          	// There must be a memory barrier between dispose() and destroy()
          	// to ensure that the effects of dispose() are observed in the
          	// thread that runs destroy().
          	// See http://gcc.gnu.org/ml/libstdc++/2005-11/msg00136.html
          	if (_Mutex_base<_Lp>::_S_need_barriers)
          	{
            	__atomic_thread_fence (__ATOMIC_ACQ_REL);
          	}

          	// Be race-detector-friendly.  For more info see bits/c++config.
          	_GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count);
          	//减少弱引用计数，并返回-1之前的值
          	//如果弱引用计数为0，则销毁控制块自身
	        if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, -1) == 1)
          	{
            	_GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count);
	          	_M_destroy();
          	}
        }
	}
};

这里再说明一下为什么__shared_count要在引用计数减为0时还要对弱引用计数做减1操作：
在__shared_count构造的同时，也会构造一个控制块对象，其中引用计数和弱引用计数一同被初始化为1。这意味着，即使最后一个std::weak_ptr被销毁了，但若其对应的std::shared_ptr还至少存在一个，那么弱引用计数就不会被减少至0（代码中的注释也是这么提示的）。

//file: shared_ptr_base.h
template<_Lock_policy _Lp = __default_lock_policy>
class _Sp_counted_base : public _Mutex_base<_Lp>
{
	_Atomic_word  _M_use_count;     // #shared
	_Atomic_word  _M_weak_count;    // #weak + (#shared != 0)
};

在std::shared_ptr对象存在的情况下，所有相关std::weak_ptr对象被销毁后，控制块仍存在，且其中的弱引用计数为1，此时在销毁最后一个std::shared_ptr对象时，除了要减少引用计数为0，释放管理的内存资源，还要把最后一个弱引用计数减少为0，销毁控制块。

在std::weak_ptr对象存在的情况下，所有相关std::shared_ptr对象都被销毁后，①std::shared_ptr管理的内存资源会被释放（因为引用计数为0，_M_dispose()被调用）②弱引用计数不为0，控制块仍然存在（直到最后一个std::weak_ptr对象被销毁，控制块才会被销毁）

参考文章

1.C++2.0 shared_ptr和weak_ptr深入刨析
2.智能指针std::weak_ptr

paw5zx
关注
  • 13
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
smartptr——基于自动引用计数的智能指针
10-14
智能指针相信大家听说过吧，我理解的智能指针，既是一个C++模板类，重载了指针操作符（->）和（*）操作符，而使它的实例可以"用指针的形式去调用"。 它可以接管任意类型的指针，所以你只需要放心大胆的new出任意对象...
c++ primer 第5版（李普曼） part3
07-31
难以计数的程序员已经通过旧版的《C++ Primer》学会了C++语言。而在这段时间中，C++本身又已成熟了许多：语言本身的关注点和程序设计社区的关注点都已大大开阔，已经从主要关注机器效率转变为更多地关注编程效率。 ...
C++智能指针3——弱指针weak_ptr详解
xuyouqiang1987的博客
01-30 6774
共享指针shared_ptr指针存在的一些问题可以有弱指针weak_ptr解决。
C++ STL 四种智能指针
热门推荐
Dablelv 的博客专栏。
08-07 7万+
auto_ptrunique_ptrshared_ptrweak_ptrauto_ptr 是 C++98 提出的，C++11 已将其摒弃，并提出了 unique_ptr 替代 auto_ptr。虽然 auto_ptr 已被摒弃，但在实际项目中仍可使用，但建议使用更加安全的 unique_ptr，后文会详细叙述。shared_ptr 和 weak_ptr 则是 C+11 从准标准库 Boost 中引入的两种智能指针。
C++智能指针——弱指针
weixin_43945471的博客
03-17 517
C++智能指针——弱指针
【c++复习笔记】——智能指针详细解析(智能指针的使用,原理分析)
sjp11的博客
04-03 3万+
💂 个人主页:努力学习的少年 🤟 版权: 本文由【努力学习的少年】原创、在CSDN首发、需要转载请联系博主 💬 如果文章对你有帮助、欢迎关注、点赞、收藏(一键三连)和订阅专栏哦
C++常见面试题 ——智能指针
weixin_44438755的博客
02-22 1474
智能指针是类模板，指针是C/C++中一个变量类型，存放的是内存地址。在使用上，智能指针和裸指针都支持解引用*，->等操作，但智能指针提供包含许多额外的函数。智能指针使用指向堆分配对象的原始指针进行初始化，初始化后，智能指针拥有原始指针。智能指针负责对原始指针的释放。智能指针使用RAII机制，管理堆内存中的数据。当智能指针超过其作用域，或者抛出异常时，就会调用智能指针的析构函数，自动释放堆上的内存数据。
C++智能指针2——共享指针shared_ptr详解
xuyouqiang1987的博客
01-29 2万+
目录 简介 示例 代码 输出 创建 定义删除器 示例 处理数组 销毁其他资源 接口列表 隐式指针转换 比较运算符 获取删除器 别名构造函数 make_shared()和allocate_shared() 强制类型转换 线程安全的接口 使用错误 简介 共享指针shared_ptr是具有共享所有权语义的智能指针。 每当共享指针shared_ptr的最后一个所有者...
详解C++智能指针及交叉引用问题
偶然i的博客
04-01 3034
技术交流qq：1032492413 技术交流VX:Chamfion
【C++学习】智能指针
weixin_63726869的博客
05-27 2013
介绍了智能指针产生的原因以及原理(RAII和像指针一样)，还有多版本的智能指针，拷贝会悬空的auto_ptr，不能拷贝和赋值的unique_ptr，比较完美的shared_ptr，为了解决循环引用的weak_ptr，以及智能指针的线程安全，最后还介绍了定制删除器。
C++智能指针循环引用问题分析.pdf
02-27
C++智能指针循环引⽤问题分析 C++11中引⼊了三种智能指针，分别是shared_ptr、weak_ptr和unique_ptr 智能指针的作⽤ 智能指针可以帮助我们管理动态分配的堆内存，减少内存泄漏的可能性 ⼿动管理堆内存有引起内存泄漏...
C++智能指针原理.pdf
02-27
C++智能指针原理 C++智能指针 1. 智能指针原理 采⽤C++ Primer Plus中作者引出智能指针的⽅式进⾏说明，感觉超好。 ⾸先看2个函数： //函数1 void remodel(std::string & str) { std::string * ps = new std::string...
C++智能指针shared-ptr讲解与使用.pdf
02-27
C++智能指针shared_ptr讲解与使⽤ ⼿动管理的弊端 在简单的程序中，我们不⼤可能忘记释放 new 出来的指针，但是随着程序规模的增⼤，我们忘了 delete 的概率也随之增⼤。在 C++ 中 new 出来的指针，赋值意味着引⽤的...
初识C语言——第二十一天
硬件菜鸟的成长之路
05-15 619
1.rand()函数是只能生成伪随机数，并且无返回值，使用前需调用srand()伪随机数生成器作为起点2.time（）函数是结构体函数，返回值是64为整数类型，可以通过time函数生成时间戳时间戳-函数调用的时间点和计算机的初始时间点之间的时间间隔3.void（）函数-无返回值类型函数4.while(1)-一直循环，直到break跳出。
【CCF-CSP】202312-4 宝藏
whaoe_m的博客
05-14 408
对于所有类型为 2的事件，输出一行四个非负整数 C1,1​,C1,2​,C2,1​,C2,2​，表示该时刻的密码 C。西西艾弗岛上埋藏着一份宝藏，小 C 根据藏宝图找到了宝藏的位置。由于小 C 并不会这个问题，他向你发起了求助。你需要帮助小 C 求出所有类型为 22 的事件所对应的密码。小 C 将所有的时刻发生的事件均记录了下来。输入的第一行包含两个正整数n,m。从标准输入读入数据。
C++ 11
qq_65112813的博客
05-17 657
对于类类型，如果定义了接受。
手搓顺序表（C语言）
最新发布
m0_62646213的博客
05-19 818
顺序表头插头删，尾插尾删，任意位置插入删除的实现和优劣分析
c++ 智能指针循环引用
07-27
循环引用是指两个或多个对象相互持有对方的指针，导致它们无法被正确地释放。在 C++ 中，使用智能指针可以帮助解决循环引用的问题。 C++ 提供了两种常见的智能指针：shared_ptr 和 weak_ptr。shared_ptr 是一种强引用，它会增加引用计数，并在引用计数为零时释放对象。weak_ptr 则是一种弱引用，它不会增加引用计数，并且可以检测到对象是否已释放。 使用 shared_ptr 和 weak_ptr 可以打破循环引用。例如，如果两个对象相互持有对方的 shared_ptr，可以将其中一个对象的指针改为 weak_ptr。这样，在释放对象时，由于 weak_ptr 不会增加引用计数，不会导致循环引用。 以下是一个示例代码： ```cpp #include <memory> class B; // 前向声明 class A { public: std::shared_ptr<B> b_ptr; }; class B { public: std::weak_ptr<A> a_ptr; }; int main() { std::shared_ptr<A> a = std::make_shared<A>(); std::shared_ptr<B> b = std::make_shared<B>(); a->b_ptr = b; b->a_ptr = a; return 0; } ``` 在上述示例中，A 类和 B 类相互持有对方的智能指针。为了避免循环引用，将 B 类中的 a_ptr 改为 weak_ptr，这样就不会导致循环引用的问题。 使用智能指针可以有效地管理资源，避免内存泄漏和循环引用的问题，但仍需谨慎使用，确保正确处理对象间的所有关联。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值