boost/smart_ptr - siki@wiki

すべてのスマートポインタを利用可能にするヘッダ。

#include <boost/shared_ptr.hpp>

boost::shared_ptr<T>

#include <boost/shared_ptr.hpp>

namespace boost{
template<class T> class shared_ptr{
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);
    shared_ptr & operator=(shared_ptr const & r);
    template<class Y> explicit shared_ptr(weak_ptr<Y> const & r);
    template<class Y> shared_ptr(shared_ptr<Y> const & r );
    template<class Y> shared_ptr(shared_ptr<Y> const & r, T * p )
    template<class Y> explicit shared_ptr(std::auto_ptr<Y> & r);
    template<class Y> shared_ptr & operator=(shared_ptr<Y> const & r);
    template<class Y> shared_ptr & operator=(std::auto_ptr<Y> & r);
    shared_ptr(shared_ptr && r);
    template<class Y> shared_ptr(shared_ptr<Y> && r);
    shared_ptr & operator= (shared_ptr && r);
    template<class Y> shared_ptr & operator=(shared_ptr<Y> && r);
 
    void reset();
    template<class Y> void reset(Y * p);
    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;
    T * operator-> () const;
    T * get() const;
    operator bool () const;
    bool operator! () const;
    bool unique() const;
    long use_count() const;
    void swap(shared_ptr<T> & other);
};  // shared_ptr
 
 
template<class T, class U> inline bool operator==(shared_ptr<T> const & a, shared_ptr<U> const & b);
template<class T, class U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<U> const & b);
template<class T> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<T> const & b);
template<class T, class U> inline bool operator<(shared_ptr<T> const & a, shared_ptr<U> const & b);
template<class T> inline void swap(shared_ptr<T> & a, shared_ptr<T> & b);
template<class T, class U> shared_ptr<T> static_pointer_cast(shared_ptr<U> const & r);
template<class T, class U> shared_ptr<T> const_pointer_cast(shared_ptr<U> const & r);
template<class T, class U> shared_ptr<T> dynamic_pointer_cast(shared_ptr<U> const & r);
template<class T, class U> shared_ptr<T> shared_static_cast(shared_ptr<U> const & r);
template<class T, class U> shared_ptr<T> shared_dynamic_cast(shared_ptr<U> const & r);
template<class T, class U> shared_ptr<T> shared_polymorphic_cast(shared_ptr<U> const & r);
template<class T, class U> shared_ptr<T> shared_polymorphic_downcast(shared_ptr<U> const & r);
template<class T> inline T * get_pointer(shared_ptr<T> const & p);
template<class D, class T> D * get_deleter(shared_ptr<T> const & p);
 
} // namespace boost
 
 

boost::shared_array<>

#include <boostr/shared_array.hpp>

boost::weak_ptr<>

#include <boostr/weak_ptr.hpp>

boost::scoped_ptr<>

#include <boostr/scoped_ptr.hpp>

boost::scoped_array<>

#include <boostr/scoped_array.hpp>

boost::intrusive_ptr<>

#include <boostr/intrusive_ptr.hpp>