Re: [boost] Re: Re: Re: Re: shared_ptr comparison

From: Greg Colvin (gcolvin_at_[hidden])
Date: 2001-08-23 10:59:36

----- Original Message ----- 
From: Kevlin Henney <kevlin_at_[hidden]>
To: <boost_at_[hidden]>
Sent: Thursday, August 23, 2001 12:33 AM
Subject: [boost] Re: Re: Re: Re: shared_ptr comparison

> >   From: John Max Skaller <skaller_at_[hidden]>
> >
> >       Doing so means the answer is: "replace that C array
> >with array<T>, and use smart_ptr< array<T> >", rather than
> >"use array_ptr<T>" no matter what it is named. 
> 
> Greg has already pointed out the existing boost::array template, which
> was one of the first submissions to Boost. It is a fixed-size array, so
> although it addresses the common concerns of actual declared C arrays,
> it does not address the new T[] issue, which is closer in spirit to
> vector than array -- scoped_ptr< array<T, N> > is actually not that
> useful when compared to scoped_array<T>.
> 
> On a point of usage, scoped_array<T> is also not the moral equivalent to
> scoped_ptr< array<T, N> > or scoped_ptr< vector<T> >: the usage is at a
> different level of indirection, so it is not a comparison of like for
> like.

Here are the currently available usages:

   boost::scoped_ptr<T>   p = new T;
   boost::scoped_array<T> p = new T[n];
   std::auto_ptr<T>       p = new T;        
   boost::shared_ptr<T>   p = new T;
   boost::shared_array<T> p = new T[n];

The following can of course be used as T above:

   std::vector
   boost::array

There is really no use I can see for scoped_ptr<array<T>> or
scoped_ptr<vector<T>>. Shared_ptr is useful, but requires a
clumsy indirection in use.  So perhaps we could provide a
new container

    boost::shared_vector<T> p = new vector<T,n>;
    boost::shared_vector<T> p = new array<T,N>;

with appropriate operator[] and forwarding members for other
vector functions.  This would reduce the need for scoped_array
and shared_array.  Perhaps instead of shared_vector we can
specialize shared_array for array<T,N>* ?

I also wonder if the core language could change so that the
type of new T[n] is pointer to array of T instead of pointer
to T.  It seems that this change could prevent misuse of the
scoped_array and shared_array templates, but perhaps it will
fall afoul of the automatic decay of array types to pointers.