boost库智能指针，循环引用，定置删除器详解

最新推荐文章于 2024-03-28 18:03:21 发布
最新推荐文章于 2024-03-28 18:03:21 发布
阅读量1.6k 收藏 2
点赞数 1
分类专栏： C/C++ 文章标签： 智能指针 boost
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lixungogogo/article/details/52551771
版权

　　智能指针用于指向存放在堆，即动态分配对象指针的类，用于对指针所指向的对象生存期的控制，防止内存泄露。
　　boost库中的智能指针定义在namespace boost中，包括：
　　shared_ptr
　　weak_ptr
　　scoped_ptr
　　shared_arr
　　scoped_arr

auto_ptr

　　auto_ ptr是在std库中的，不在boost库中，但是auto_ptr能够说清楚智能指针的原理，所以在这里说一下。
　　auto_ptr用于指向一个动态分配的对象指针，他的析构函数用于删除所值对象的空间，以此达到对对象生存期的控制。
　　auto_ ptr在进行拷贝构造和赋值的时候，会对控制权进行转移，即当另一个auto_ ptr要指向一个已经被另一个auto_ ptr控制的对象的时候，以前那个auto_ ptr必须释放控制权。
　　就像下面这样：
这里写图片描述
　　原因：
　　如果不这样做，在析构的时候就会对同一段内存空间析构两次，造成错误。
　　但是仅仅对拷贝构造和赋值进行限制不能完全保证没有两个智能指针指向同一个对象，所以auto_ptr是不好的。
　　下面是我自己实现auto_ptr的代码：
　　

template <typename T>
class AutoPtr
{
public:
    AutoPtr(T* ptr = NULL)
        :_ptr(ptr)
    {}
    AutoPtr(const AutoPtr& a)
    {
        _ptr = a._ptr;
        a._ptr = NULL;
    }
    AutoPtr& operator = (const AutoPtr& a)
    {
        if (this != &a)
        {
            _ptr = a._ptr;
            a._ptr = NULL;
        }
        return *this;
    }
    ~AutoPtr()
    {
        delete _ptr;
    }
    T& operator*()
    {
        if (_ptr == NULL)
        {
            throw a;
        }
        return *_ptr;
    }

    T* operator ->()const
    {
        if (_ptr == NULL)
        {
            throw a;
        }
        return _ptr;
    }
    bool operator == (const AutoPtr& a)
    {
        return (_ptr == a._ptr);
    }
    bool operator !=(const AutoPtr& a)
    {
        return (_ptr != a._ptr);
    }
    void Reset(T* ptr = NULL)
    {
        if (_ptr != ptr)
        {
            delete _ptr;
        }
        _ptr = ptr;
    }
private:
    T* _ptr;
};

scoped_ptr

　　auto_ ptr在使用的时候，会有控制权的转移。其实scoped_ ptr的原理与auto_ ptr是相同的，只不过scoped_ ptr完全不允许控制权的转移，即将拷贝构造函数和赋值运算符重载函数都声明为私有的了，外部不允许调用。
　　下面的代码是boost库中scoped_ptr的代码：
　　代码中的explict关键字表示不允许隐式调用构造函数，保证了不转移控制权。


template<class T> class scoped_ptr // noncopyable
{
private:

    T * px;

    scoped_ptr(scoped_ptr const &);
    scoped_ptr & operator=(scoped_ptr const &);

    typedef scoped_ptr<T> this_type;

    void operator==( scoped_ptr const& ) const;
    void operator!=( scoped_ptr const& ) const;

public:

    typedef T element_type;

    explicit scoped_ptr( T * p = 0 ): px( p ) // never throws
    {
#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
        boost::sp_scalar_constructor_hook( px );
#endif
    }

#ifndef BOOST_NO_AUTO_PTR

    explicit scoped_ptr( std::auto_ptr<T> p ): px( p.release() ) // never throws
    {
#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
        boost::sp_scalar_constructor_hook( px );
#endif
    }

#endif

    ~scoped_ptr() // never throws
    {
#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
        boost::sp_scalar_destructor_hook( px );
#endif
        boost::checked_delete( px );
    }

    void reset(T * p = 0) // never throws
    {
        BOOST_ASSERT( p == 0 || p != px ); // catch self-reset errors
        this_type(p).swap(*this);
    }

    T & operator*() const // never throws
    {
        BOOST_ASSERT( px != 0 );
        return *px;
    }

    T * operator->() const // never throws
    {
        BOOST_ASSERT( px != 0 );
        return px;
    }

    T * get() const // never throws
    {
        return px;
    }

// implicit conversion to "bool"
#include <boost/smart_ptr/detail/operator_bool.hpp>

    void swap(scoped_ptr & b) // never throws
    {
        T * tmp = b.px;
        b.px = px;
        px = tmp;
    }
};

shared_ptr

　　在实际应用中，我们往往需要复制智能指针，上面的auto_ptr和scoped_ptr都不能满足我们的需求。
　　所以出现了shared_ptr，shared_ptr是采用引用计数的方法防止多次析构。
　　我们为每一个指针都维护一个引用计数，一旦多了一个智能指针指向那个内存的时候，引用计数加一，少了一个智能指针指向对象时，引用计数减一。
　　在析构的时候，每析构一次，引用计数减一，直到引用计数为0的时候，再析构对象及引用计数所占用的空间。
　　原理如下：
　　这里写图片描述
　　下面是我的代码模拟实现：
　　

template <typename T>
class SharedPtr
{
public:
    SharedPtr(T* ptr = NULL)
        :_ptr(ptr)
        , _ref(new int(0))
    {
        if (_ptr != NULL)
            (*_ref)++;
    }
    SharedPtr(const SharedPtr&a)
    {
        _ptr = a._ptr;
        _ref = a._ref;
        if (_ptr != NULL)
            (*_ref)++;
    }
    ~SharedPtr()
    {
        if (--(*_ref) == 0)
        {
            delete _ptr;
            delete _ref;
        }
    }
    SharedPtr& operator=(const SharedPtr &a)
    {
        if (this != &a)
        {
            if (--(*_ref) <= 0)
            {
                delete _ptr;
                delete _ref;
            }
            else{}
            _ptr = a._ptr;
            _ref = a._ref;
            (*_ref)++;
        }
        return *this;
    }
    T operator*()
    {
        return *_ptr;
    }
    T* operator ->()
    {
        return _ptr;
    }
    bool operator == (const SharedPtr& a)
    {
        return (_ptr == a._ptr);
    }
    bool operator !=(const SharedPtr& a)
    {
        return (_ptr != a._ptr);
    }
private:
    T* _ptr;
    int* _ref;
};

线程不安全

　　因为使用引用计数值为判定指标，所以在多线程的环境下，是线程不安全的，会因线程调用的先后顺序产生错误结果。
　　解决方法：
　　使用锁，对引用计数操作进行加锁，保证操作是互斥的。

循环引用问题

　　因为shared_ptr是通过引用计数进行生存期控制的，所以会出现循环引用问题。
　　我现在用下面的代码来解释循环引用的问题
　　

class B;
class A
{
public:// 为了省去一些步骤这里 数据成员也声明为public
  shared_ptr<B> pb;
  void doSomthing()
  {
  }

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

class B
{
public:
  shared_ptr<A> pa;
  ~B()
  {
    cout <<"~B";
  }
};

int main(int argc, char** argv)
{
  shared_ptr<A> sa(new A());
  shared_ptr<B> sb(new B());
  if(sa && sb)
  {
    sa->pb=sb;
    sb->pa=sa;
  }
  cout<<"sa use count:"<<sa.use_count()<<endl;
  return 0;
}

　　一旦运行上面的代码，运行结果为：sa use count:2， 注意此时sa,sb都没有释放，产生了内存泄露问题
　　即A内部有指向B，B内部有指向A，这样对于A，B必定是在A析构后B才析构，对于B，A必定是在B析构后才析构A，这就是循环引用问题，违反常规，导致内存泄露。
　　循环引用出现的场景：
　　如二叉树中父节点与子节点的循环引用，容器与元素之间的循环引用等。

weak_ptr

　　解决上面循环引用的一个方法就是使用weak_ptr，weak_ptr是结合shared_ptr使用的智能指针。
　　weak_ ptr允许对一个或多个shared_ptr所指向的对象进行访问，但是不对引用计数值进行改变，即观察对象，但不对对象进行改变。
　　weak_ ptr的实现没有实现->与*运算符的重载，所以不能直接使用weak_ ptr访问对象。
　　boost库提供了expired()与lock()成员函数，前者用于判断weak_ ptr指向的对象是否已被销毁，后者返回其所指对象的shared_ ptr智能指针(对象销毁时返回”空“shared_ptr)。
　　boost库中weak_ptr的实现：
　　


template<class T> class weak_ptr
{
private:

    // Borland 5.5.1 specific workarounds
    typedef weak_ptr<T> this_type;

public:

    typedef T element_type;

    weak_ptr(): px(0), pn() // never throws in 1.30+
    {
    }

    template<class Y>
#if !defined( BOOST_SP_NO_SP_CONVERTIBLE )

weak_ptr( weak_ptr<Y> const & r, typename boost::detail::sp_enable_if_convertible<Y,T>::type = boost::detail::sp_empty() )

#else

    weak_ptr( weak_ptr<Y> const & r )

#endif
    : px(r.lock().get()), pn(r.pn) // never throws
    {
    }

#if defined( BOOST_HAS_RVALUE_REFS )

    template<class Y>
#if !defined( BOOST_SP_NO_SP_CONVERTIBLE )

    weak_ptr( weak_ptr<Y> && r, typename boost::detail::sp_enable_if_convertible<Y,T>::type = boost::detail::sp_empty() )

#else

    weak_ptr( weak_ptr<Y> && r )

#endif
    : px( r.lock().get() ), pn( static_cast< boost::detail::weak_count && >( r.pn ) ) // never throws
    {
        r.px = 0;
    }

    // for better efficiency in the T == Y case
    weak_ptr( weak_ptr && r ): px( r.px ), pn( static_cast< boost::detail::weak_count && >( r.pn ) ) // never throws
    {
        r.px = 0;
    }

    // for better efficiency in the T == Y case
    weak_ptr & operator=( weak_ptr && r ) // never throws
    {
        this_type( static_cast< weak_ptr && >( r ) ).swap( *this );
        return *this;
    }


#endif

    template<class Y>
#if !defined( BOOST_SP_NO_SP_CONVERTIBLE )

    weak_ptr( shared_ptr<Y> const & r, typename boost::detail::sp_enable_if_convertible<Y,T>::type = boost::detail::sp_empty() )

#else

    weak_ptr( shared_ptr<Y> const & r )

#endif
    : px( r.px ), pn( r.pn ) // never throws
    {
    }

#if !defined(BOOST_MSVC) || (BOOST_MSVC >= 1300)

    template<class Y>
    weak_ptr & operator=(weak_ptr<Y> const & r) // never throws
    {
        px = r.lock().get();
        pn = r.pn;
        return *this;
    }

#if defined( BOOST_HAS_RVALUE_REFS )

    template<class Y>
    weak_ptr & operator=( weak_ptr<Y> && r )
    {
        this_type( static_cast< weak_ptr<Y> && >( r ) ).swap( *this );
        return *this;
    }

#endif

    template<class Y>
    weak_ptr & operator=(shared_ptr<Y> const & r) // never throws
    {
        px = r.px;
        pn = r.pn;
        return *this;
    }

#endif

    shared_ptr<T> lock() const // never throws
    {
        return shared_ptr<element_type>( *this, boost::detail::sp_nothrow_tag() );
    }

    long use_count() const // never throws
    {
        return pn.use_count();
    }

    bool expired() const // never throws
    {
        return pn.use_count() == 0;
    }

    bool _empty() const // extension, not in std::weak_ptr
    {
        return pn.empty();
    }

    void reset() // never throws in 1.30+
    {
        this_type().swap(*this);
    }

    void swap(this_type & other) // never throws
    {
        std::swap(px, other.px);
        pn.swap(other.pn);
    }

    void _internal_assign(T * px2, boost::detail::shared_count const & pn2)
    {
        px = px2;
        pn = pn2;
    }

    template<class Y> bool _internal_less(weak_ptr<Y> const & rhs) const
    {
        return pn < rhs.pn;
    }

// Tasteless as this may seem, making all members public allows member templates
// to work in the absence of member template friends. (Matthew Langston)

#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS

private:

    template<class Y> friend class weak_ptr;
    template<class Y> friend class shared_ptr;

#endif

    T * px;                       // contained pointer
    boost::detail::weak_count pn; // reference counter

};

强引用和弱引用

　　一个强引用当被引用的对象活着的话，这个引用也存在（就是说，当至少有一个强引用，那么这个对象就不能被释放）。
　　share_ptr就是强引用。相对而言，弱引用当引用的对象活着的时候不一定存在。仅仅是当它存在的时候的一个引用。
　　弱引用并不修改该对象的引用计数，这意味这弱引用它并不对对象的内存进行管理，在功能上类似于普通指针，然而一个比较大的区别是，弱引用能检测到所管理的对象是否已经被释放，从而避免访问非法内存。

使用weak_ptr来打破循环引用

代码如下：

#include <iostream>
#include <memory>
using namespace std;

class B;
class A
{
public:// 为了省去一些步骤这里 数据成员也声明为public
  weak_ptr<B> pb;
  void doSomthing()
  {
    if(pb.lock())
    {

    }
  }

  ~A()
  {
    cout << "kill A\n";
  }
};

class B
{
public:
  shared_ptr<A> pa;
  ~B()
  {
    cout <<"kill B\n";
  }
};

int main(int argc, char** argv)
{
  shared_ptr<A> sa(new A());
  shared_ptr<B> sb(new B());
  if(sa && sb)
  {
    sa->pb=sb;
    sb->pa=sa;
  }
  cout<<"sb use count:"<<sb.use_count()<<endl;
  return 0;
}

对数组进行管理

　　因为智能指针的析构函数中释放内存所用的都是delete运算符，只能释放单独的对象，不能对数组对象进行释放，所以我们必须定义一个arr智能指针，用于对数组进行管理。
　　下面给出两个我自己实现的数组智能指针

auto_arr

template <typename T>
class AutoArry
{
public:
    AutoArry(T* ptr = NULL)
        :_ptr(ptr)
    {}
    ~AutoArry()
    {
        delete[] _ptr;
    }
    AutoArry(const AutoArry& a)
    {
        _ptr = a._ptr;
        a._ptr = NULL;
    }

    AutoArry& operator = (const AutoArry& a)
    {
        if (this != &a)
        {
            _ptr = a._ptr;
            a._ptr = NULL;
        }
        return *this;
    }
    T& operator*()
    {
        if (_ptr == NULL)
        {
            throw a;
        }
        return *_ptr;
    }
    T* operator->()
    {
        if (_ptr == NULL)
        {
            throw a;
        }
        return _ptr;
    }
    T& operator[](size_t index)
    {
        if (_ptr == NULL)
        {
            throw a;
        }
        return *(_ptr + index);
    }
    T& operator[](size_t index)const
    {
        if (_ptr == NULL)
        {
            throw a;
        }
        return *(_ptr + index );
    }
    void set(T* ptr)
    {
        int i = 0;
        while (*(ptr+i))
        {
            *(_ptr + i) = *(ptr+i);
            i++;
        }
    }
private:
    T* _ptr;
};

shared_arr

　　对数组进行管理，依旧是使用引用计数。
　　

template <typename T>
class SharedArr
{
public:
    SharedArr(T* ptr = NULL)
        :_ptr(ptr)
        , _ref(new int(0))
    {
        if (_ptr != NULL)
        {
            (*_ref)++;
        }
    }
    SharedArr(const SharedArr& a)
    {
        _ptr = a._ptr;
        (*_ref)++;
    }
    ~SharedArr()
    {
        if (--(*_ref) == 0)
        {
            delete[] _ptr;
            delete _ref;
        }
    }
    SharedArr& operator=(SharedArr& a)
    {
        if (this != &a)
        {
            if (--(*_ref) <= 0)
            {
                if (_ptr != NULL)
                    delete[] _ptr;
                delete _ref;
            }
            else {}
            _ptr = a._ptr;
            _ref = a._ref;
            (*_ref)++;
        }
        return *this;
    }
    T& operator[](size_t index)
    {
        if (_ptr == NULL)
        {
            throw a;
        }
        return *(_ptr + index);
    }
    T& operator[](size_t index) const 
    {
        if (_ptr == NULL)
        {
            throw a;
        }
        return *(_ptr + index);
    }
    T& operator*( )
    {
        if (_ptr == NULL)
        {
            throw a;
        }
        return (*_ptr);
    }
    T* operator->()
    {
        if (_ptr == NULL)
        {
            throw a;
        }
        return _ptr;
    }
private:
    T* _ptr;
    int* _ref;
};

定置删除器

　　经过上面的分析，我们都可以看到智能指针可以实现对内存的管理，简单的实现了垃圾回收机制，但是，上面所说的智能指针都不能用于文件。因为他的析构函数使用的是delete运算符。
　　所以我们使用仿函数以及函数指针构成定置删除器。
　　代码如下：
　　

//定置删除器的仿函数
struct Fclose
{
       void operator()(void *ptr)
       {
              fclose((FILE *)ptr);
              cout << "fclose()" << endl;
       }
};
void test()
{
       boost::shared_ptr<FILE> sp(fopen("test.txt","w"),Fclose());    //调用构造函数构造一个匿名对象传递过去，文件正常关闭
}
//2.用智能指针管理malloc开辟的动态内存，那么我们在释放的时候就要用free释放：
//定置删除器的仿函数
struct Free
{
       void operator()(void *ptr)
       {
              free(ptr);
       }
};
void test()
{
       boost::shared_ptr<int> sp((int*)malloc(sizeof(int)),Free());        //能够正确的释放空间
}
长着胡萝卜须的栗子
关注
专栏目录
详解Boost库智能指针（shared_ptr && scoped_ptr && weak_ptr ）
NK_test的博客
01-30 4023
我们先来解释一下什么叫智能指针？ 智能指针是利用RAII（在对象的构造函数中执行资源的获取（指针的初始化），在析构函数中释放（delete 指针）：这种技法把它称之为RAII（Resource Acquisition Is Initialization：资源获取即初始化））来管理资源。 其本质思想是：将堆对象的生存期用栈对象（智能指针）来管理。也就是当new一个堆对象的时候，立刻用智能指针来接
建议慎用boost::weak_ptr来避免智…
runyon的博客
10-10 2355
如果让我说C/C++相比拥有GC机制的语言如Java，开发时感觉最大的不同是什么。我想繁琐易错的内存管理肯定会排在第一位。所以自从见到基于RAII的boost智能指针实现，觉得日子好过了很多呵呵。智能指针相比GC，优点很多：效率高计算代价低即时性好。但有一个很致命的缺陷：当存在循环引用的时候将会导致内存泄露。所以还是GC舒服啊。     为了降低智能指针循环引用的可能性，boost智能指针引入了
智能指针（下）-----boost库智能指针，定制删除器、循环引用
丁香枝上，豆蔻梢头
04-15 570
上一篇我们已经详细讲解了智能指针的基础性知识和auto_ptr的模拟实现。 今天呢我们来讲解boost库的发展。 在C++11标准出来之前，C++98标准中都一直只有一个智能指针auto_ptr，我们知道，这是一个失败的设计。它的本质是管理权的转移，这有许多问题。而这时就有一群人开始扩展C++标准库的关于智能指针的部分，他们组成了boost社区，他们负责boost库的开发和维护。其目的是为C++
C++:Boost库智能指针_删除器
互联网时代，属于我们的时代！
08-13 1095
智能指针_删除器：可以针对特殊的对象进行特殊释放 #include #include using namespace std; using namespace boost; //删除器 //函数对象 operator() void My_Delete(int *p) //特别定制的删除器 { delete p; } int main() { int *p = new int(1
boost中的指针容器
mo4776的博客
02-27 1132
boost中的指针容器 基本概念 在C++中用容器来管理动态分配的内存，首先想到是会通过标准容器来存储boost::shared_ptr，如下代码: #include &amp;amp;amp;amp;lt;boost/shared_ptr.hpp&amp;amp;amp;amp;gt; #include &amp;amp;amp;amp;lt;vector&amp;amp;amp;amp;gt; int main()
智能指针与多线程
最新发布
木牛的博客
03-28 144
对于read端，在读之前把引用计数加1，读完后减1，这样保证在读期间，引用计数大于1，保证读取时对象不会被析构，也可以阻止并发写。shared_ptr是值语义，当心意外延长对象的生命周期，例如bind和容器都可能拷贝shared_ptr。shared_ptr会延长对象的生命周期，只要有一个指向x对象的shared_ptr，该对象就不会析构。线程B调用write，此时g_foos指向的对象已经被释放，拷贝一个已经释放的对象，程序崩溃；weak_ptr是shared_ptr的好搭档，可以作弱回调、对象池等。
Boost智能指针
01-02
### Boost智能指针详解 #### 一、智能指针概述 智能指针是C++中用于自动管理动态分配内存的一种工具。与原始指针不同，智能指针通过封装额外的操作来帮助开发者避免常见的内存泄漏和其他资源管理问题。Boost库提供...
C++智能指针详解.pdf
02-27
智能指针在生命周期结束时会自动调用删除器（deleter）来释放其所指向的对象，确保内存得到正确清理。在C++11及更高版本中，标准库提供了多种智能指针类型，包括std::unique_ptr、std::shared_ptr和std::weak_ptr。 ...
浅析Boost智能指针:scoped_ptr shared_ptr weak_ptr
09-05
`boost::weak_ptr` 是一个弱引用智能指针，它不拥有对象，但可以监视对象的存在状态。主要用于解决循环引用的问题，当对象被`shared_ptr`引用时，`weak_ptr`可以检测到对象是否仍然存在。 #### 特点： 1. **非拥有...
boost 智能指针
08-23
### Boost智能指针详解 #### Boost库概述 Boost是一个免费、可移植且经过同行评审的C++库集合，因其高质量的代码和卓越的设计而受到广泛赞誉。Boost库不仅包括多种功能性的工具，如智能指针、正则表达式、线程库等...
智能指针的简单分析(二)——shared_ptr
明月漫千山
07-16 211
自己实现一个shared_ptr. template&lt;typename Ty&gt; class MySharedPtr {     typedef typename Ty* pointer;     typedef typename Ty* MyRef; private:     int* m_pnCount;     pointer m_ptPointer; public:    ...
boost编译开关宏参考手册(中文)
jwybobo2007的博客
03-26 5126
http://boost.ez2learn.com/libs/config/doc/html/boost_config/boost_macro_reference.html Boost 宏参考 描 述缺陷的宏描 述可选特性的宏描 述可能的 C++0x 特性的宏描 述不被支持的 C++0x 特性的宏Boost 辅助宏Boost 信息宏用 於分隔源代码的宏
Boost源代码学习---weak_ptr.hpp
weixin_30739595的博客
07-17 123
weak_ptr是辅助shared_ptr的智能指针。就像它的名字一样。是个“弱”指针；仅有几个接口。仅能完毕非常少工作。它能够从一个shared_ptr或weak_ptr对象构造。获取对资源的观測权。它是没有共享资源的，所以它的对象的创建不会引起指针引用计数的添加，它的对象的析构也不会引起计数器的降低。 它没有重载*和->。不能使用指针。基本的几个接口例如以下： lo...
C++智能指针循环引用解决
爱.NET
10-17 271
参考文章：http://www.cnblogs.com/TianFang/archive/2008/09/20/1294590.html。 前言：C++中智能指针的引入，使得开发人员在与内存的斗争中占据上峰。然而凡事都不会尽善尽美，智能指针的循环引用缺陷还是会引发令人谈虎色变的内存泄露。本文的内容就是讲述，如何解决循环引用带来的内存问题。 背景：智能指针采用Boost库，语言C++，开发工具V...
[6] 智能指针boost::weak_ptr
weixin_33840661的博客
09-02 240
【1】boost::weak_ptr简介 boost::weak_ptr属于boost库，定义在namespace boost中，包含头文件 #include&lt;boost/weak_ptr.hpp&gt;便可以使用。 【2】boost::weak_ptr详解 智能指针boost::scope_ptr和智能指针boost::shared_ptr就完全可以解决所有单个对象内存的管理问题。 ...
关于使用boost asio库 出现的一些问题的总结
weixin_42427338的博客
10-29 7371
最近在使用boost库的时候，因为可能是自己的c++学的还不是很扎实吧，出现了很多令人啼笑皆非的错误。而且，我也不太能从一些错误提示中找到正确的解决思路。下面就是我的一个错误总结吧。 一开始我对于boost asio库的运行模式不是很理解，经过一些错误总算有一点头绪。 io_service的作用 首先asio库主要就是对一些io进行操作，其中就有我的项目比较需要的网络socket的一些io功...
boost::weak智能指针
huangjh2017的博客
02-06 295
1. 简介 　　weak_ptr 是为配合 shared_ptrt 而引入的一种智能指针，它更像是 shared_ptr 的一个助手而不是智能指针，因为它不具备普通指针的行为，没有重载 operator * 和 ->。它的最大作用在于协助 shared_ptr 工作，像旁观者那样观测资源的使用情况。 　　利用 weak_ptr，我们可以解决常见的空悬指针问题和循环引用问题。 　　空悬指针问题
Boost智能指针详解与应用
"本文档主要介绍了Boost库中的智能指针，包括它们的概念、种类以及各自的特性。" Boost智能指针是C++中解决内存管理问题的一种高效工具，它们自动管理所指向的对象生命周期，避免了手动释放内存可能导致的错误。在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值