Небольшая добавка для boost::shared_ptr, чтобы не писать постоянно boost::shared_ptr<type> p(new type, non_deleter<type>());

Полезно если не хочется создавать элементы на хипе, а передать shared_ptr надо:

Использование аналогично boost::shared_ptr, за исключением невозможности передать функтор для удаления объекта

Код:

#include <boost/shared_ptr.hpp>

template<typename T>
struct non_deleter
{
    void operator()(T*)
    {
    }
};

template<typename T>
class stack_shared_ptr : public boost::shared_ptr<T>
{
public:
    typedef boost::shared_ptr<T> base_type;

    stack_shared_ptr()
    {
    }

    template<typename Y>
    explicit stack_shared_ptr(Y* p) : base_type(p, non_deleter<T>()) // Y must be complete
    {
    }

    //
    // Requirements: A's copy constructor must not throw
    //
    template<typename Y, typename A>
    stack_shared_ptr(Y* p, A a) : base_type(p, non_deleter<T>(), a)
    {
    }

    //  generated copy constructor, assignment, destructor are fine...

    template<class Y>
    explicit stack_shared_ptr(boost::weak_ptr<Y> const & r) : base_type(r) // may throw
    {
    }

    template<class Y>
    stack_shared_ptr(stack_shared_ptr<Y> const & r) : base_type(r) // never throws
    {
    }

    template<class Y>
    stack_shared_ptr(stack_shared_ptr<Y> const & r, boost::detail::static_cast_tag tag) : base_type(r, tag)
    {
    }

    template<class Y>
    stack_shared_ptr(stack_shared_ptr<Y> const & r, boost::detail::const_cast_tag tag) : base_type(r, tag)
    {
    }

    template<class Y>
    stack_shared_ptr(stack_shared_ptr<Y> const & r, boost::detail::dynamic_cast_tag tag) : base_type(r, tag)
    {
    }

    template<class Y>
    stack_shared_ptr(stack_shared_ptr<Y> const & r, boost::detail::polymorphic_cast_tag tag) : base_type(r, tag)
    {
    }

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

    template<class Y>
    stack_shared_ptr & operator=(stack_shared_ptr<Y> const & r) // never throws
    {
        base_type::operator=(r);

        return *this;
    }

#endif
};