template<class T> class scoped_array // noncopyable
{
private:
    T * px;
    scoped_array(scoped_array const &);
    scoped_array & operator=(scoped_array const &);
    typedef scoped_array<T> this_type;
    void operator==( scoped_array const& ) const;
    void operator!=( scoped_array const& ) const;
public:
    typedef T element_type;
    explicit scoped_array( T * p = 0 ) BOOST_SP_NOEXCEPT : px( p )
    {
    }
    ~scoped_array() // never throws
    {
        boost::checked_array_delete( px );
    }
    void reset(T * p = 0) // never throws (but has a BOOST_ASSERT in it, so not marked with BOOST_NOEXCEPT)
    {
        BOOST_ASSERT( p == 0 || p != px ); // catch self-reset errors
        this_type(p).swap(*this);
    }
    T & operator[](std::ptrdiff_t i) const // never throws (but has a BOOST_ASSERT in it, so not marked with BOOST_NOEXCEPT)
    {
        BOOST_ASSERT( px != 0 );
        BOOST_ASSERT( i >= 0 );
        return px[i];
    }
    T * get() const BOOST_NOEXCEPT
    {
        return px;
    }
// implicit conversion to "bool"
#include <boost/smart_ptr/detail/operator_bool.hpp>
    void swap(scoped_array & b) BOOST_NOEXCEPT
    {
        T * tmp = b.px;
        b.px = px;
        px = tmp;
    }
};

#include <boost/scoped_ptr.hpp>
#include <iostream>
int main()
{
  boost::scoped_ptr<int> p{new int{1}};
  std::cout << *p << '\n';
  p.reset(new int{2});
  std::cout << *p.get() << '\n';
  p.reset();
  std::cout << std::boolalpha << static_cast<bool>(p) << '\n';
}

#include <boost/scoped_array.hpp>
int main()
{
  boost::scoped_array<int> p{new int[2]};
  *p.get() = 1;
  p[1] = 2;
  p.reset(new int[3]);
}