스마트 포인터sharedptr 구성 요소 사용

클래스 요약:

template<class T> class shared_ptr
{
private:

    // Borland 5.5.1 specific workaround
    typedef shared_ptr<T> this_type;

public:

    typedef T element_type;
    typedef T value_type;
    typedef T * pointer;
    typedef typename boost::detail::shared_ptr_traits<T>::reference reference;
    shared_ptr();
    template<class Y>
    explicit shared_ptr( Y * p );
    template<class Y, class D> shared_ptr(Y * p, D d);
    template<class Y, class D, class A> shared_ptr( Y * p, D d, A a );
    template<class Y>
    explicit shared_ptr(weak_ptr<Y> const & r);
    template<class Y>
    shared_ptr( weak_ptr<Y> const & r, boost::detail::sp_nothrow_tag );
    template<class Y>
    shared_ptr( shared_ptr<Y> const & r, typename boost::detail::sp_enable_if_convertible<Y,T>::type = boost::detail::sp_empty() );
    shared_ptr( shared_ptr<Y> const & r );
    template< class Y >
    shared_ptr( shared_ptr<Y> const & r, T * p );
    template<class Y>
    shared_ptr(shared_ptr<Y> const & r, boost::detail::static_cast_tag);
    template<class Y>
    shared_ptr(shared_ptr<Y> const & r, boost::detail::const_cast_tag);
    template<class Y>
    shared_ptr(shared_ptr<Y> const & r, boost::detail::dynamic_cast_tag);
    template<class Y>
    shared_ptr(shared_ptr<Y> const & r, boost::detail::polymorphic_cast_tag);
    template<class Y>
    explicit shared_ptr(std::auto_ptr<Y> & r);
    template<class Ap>
    explicit shared_ptr( Ap r, typename boost::detail::sp_enable_if_auto_ptr<Ap, int>::type = 0 );
    shared_ptr & operator=( shared_ptr const & r ) // never throws
    template<class Y>
    shared_ptr & operator=(shared_ptr<Y> const & r) //never throw
    template<class Y>
    shared_ptr & operator=( std::auto_ptr<Y> & r );
    template<class Ap>
    typename boost::detail::sp_enable_if_auto_ptr< Ap, shared_ptr & >::type operator=( Ap r );
    shared_ptr( shared_ptr && r );
    template<class Y>
    shared_ptr( shared_ptr<Y> && r, typename boost::detail::sp_enable_if_convertible<Y,T>::type = boost::detail::sp_empty() )
    shared_ptr( shared_ptr<Y> && r );
    shared_ptr & operator=( shared_ptr && r ); // never throws
     template<class Y>
    shared_ptr & operator=( shared_ptr<Y> && r ) // never throws
    void reset() ;// never throws in 1.30+
    template<class Y> void reset(Y * p) // Y must be complete
    template<class Y, class D> void reset( Y * p, D d );
    template<class Y, class D, class A> void reset( Y * p, D d, A a );
    template<class Y> void reset( shared_ptr<Y> const & r, T * p );
    reference operator* () const;// never throws
    T * operator-> () const; // never throws
    T * get() const;// never throws
    bool unique() const; // never throws
    long use_count(); const // never throws
    void swap(shared_ptr<T> & other);// never throws
    template<class Y> bool _internal_less(shared_ptr<Y> const & rhs) const;
    void * _internal_get_deleter( boost::detail::sp_typeinfo const & ti );
    bool _internal_equiv( shared_ptr const & r ) const;
private:

    template<class Y> friend class shared_ptr;
    template<class Y> friend class weak_ptr;
    T * px;                     // contained pointer
    boost::detail::shared_count pn;    // reference counter

};  // shared_ptr

shared_ptr에는 여러 가지 형식의 구조 함수가 있는데 여러 가지 가능한 상황에 응용된다.

#include <iostream>
#include <boost/smart_ptr.hpp>
using namespace boost;
using namespace std;
class shared //define a custom class
{
 public:
 shared(shared_ptr<int> p):_p(p){}
 void print()
 {
  cout << "count: " << _p.use_count()
       << "  v= " << *_p << endl;
 }
 private:
 shared_ptr<int> _p;
};
void print_func(shared_ptr<int> p)
{
 cout << "count: " << p.use_count() 
      << "  v= " << *p << endl;
}
int main()
{
 /*
 /*example1
 shared_ptr<int> sp(new int(10));//a smart_ptr pointed to int
 assert(sp.unique()); //shared_ptr is the only owner of pointer
 
 shared_ptr<int> sp2 = sp; //the second shared_ptr,copy construct
 assert(sp == sp2 && sp.use_count() == 2); 
 //Two shared_ptr equal, pointing in the same object, reference counting is 2
 *sp2 = 100; //now print *sp2
 assert(*sp == 100);
 sp.reset();//
 assert(!sp);//sp now is empty
 cout << "no problem." << endl;
     */
 /*example2*/
 shared_ptr<int> p(new int(100));
 shared s1(p),s2(p);//custom shared class object
 
 s1.print(); //3
 s2.print();//3
 
 *p = 20; //modify the value of the object which p point to
 print_func(p);//display use_count 4
 s1.print();//3
 
}