Suggestion: auto_ary

From: Daryle Walker (darylew_at_[hidden])
Date: 2001-01-06 14:55:01

Should we have a class template that is the array analogue for
std::auto_ptr?  Here's a sample implementation (not compiled), inspired from
_The C++ Standard Library: A Tutorial and Reference_ by Nicolai M. Josuttis:

namespace boost
{
    // auxiliary type for copies and assignments
    template <typename Y>
    struct auto_ary_ref
    {
        Y *  ya_;

        auto_ary_ref( Y *rhs )
            : ya_( rhs )
            {}
    };

    // allocated array memory management
    template <typename T>
    class auto_ary
    {
    private:
        T *  aa_;

    public:
        typedef T  element_type

        // constructors and destructor
        explicit  auto_ary( T *ary = 0 )  throw()
            : aa_( ary )
            {}
        explicit  auto_ary( std::size_t ary_size, T const *init_val = 0 )
          throw()
            : aa_( new T[ary_size] )
        {
            if ( init_val )
            {
                std::copy( init_val, init_val + ary_size, aa_ );
            }
        }
        auto_ary( auto_ary &old )  throw()
            : aa_( old.release() )
            {}
        auto_ary( auto_ary_ref<T> old )  throw()
            : aa_( old.ya_ )
            {}
        ~auto_ary()  throw()
            { delete [] aa_; }

        // operators
        auto_ary &  operator =( auto_ary &old )  throw()
            { reset( old.release() ); return *this; }
        auto_ary &  operator =( auto_ary_ref<T> old )  throw()
            { reset( old.ya_ ); return *this; }
        T &  operator []( std::size_t index )  const throw()
            { return aa_[index]; }
        operator T*()  const throw()
            { return aa_; }
        operator auto_ary_ref<T>()  throw()
            { return auto_ary_ref<T>( release() ); }

        // operations
        T *  get()  const throw()
            { return aa_; }
        T *  release()  throw()
            { T *tmp( aa_ ); aa_ = 0; return tmp; }
        void  reset( T *ary = 0 )  throw()
            { if ( aa_ != ary ) { delete [] aa_; aa_ = ary; } }
    };
}

I was thinking of this because:
1.  It complements the std::auto_ptr class template for single objects
2.  The "use a STL container, like std::vector, instead of arrays" refrain
also brings a bigger interface, which could be overkill if all you wanted
was a quick-and-dirty resource manager.  And, as mentioned by Howard Hinnant
in a recent post by William Kempf*, a specialized class could bring
advantages in code size or speed.
3.  The STL suggestion assumes that the user can switch his or her container
paradigm.  If there's some constraint against this, then the STL suggestion
is insultingly useless.

* William's post has Howard's suggestion of making versions of std::auto_ptr
partially specialized for array types.  I used a separate class template
since auto_ary and auto_ptr have different semantics, so one should not be
forced to match the other's interface.

-- 
Daryle Walker
Mac, Internet, and Video Game Junkie
darylew AT mac DOT com