Re: [boost] Re: container design (Was: std::complex design (Was: N-Dimensional array))

From: Howard Hinnant (hinnant_at_[hidden])
Date: 2002-03-09 11:09:45

On Friday, March 8, 2002, at 05:07  PM, Howard Hinnant wrote:

> On Friday, March 8, 2002, at 12:51  PM, Peter Dimov wrote:
>
>> No. One way to solve it (that I see) is
>>
>> template<class F> vector::vector(size_type n, F f);
>>
>> that will allocate memory and use f(this->_Ptr, n) to initialize it.
>
> The more I think about this, the more I'm beginning to like it.
>
> Official Requirements on F(T* p, size_type n):
>
> 1.  It must construct and initialize all elements in the range [p, p+n).
>
> 2.  It must have strong exception safety.  vector will not be able to
> recover from an exception when the range is partially constructed.  It
> is all or nothing.
>
> Notes:
>
> 1.  This could probably find all kinds of uses other than the one were
> aiming at.
>
> 2.  There's nothing to stop somebody from ducking initialization rules
> if that's what he really wants to do:
>
> struct uninitialized
> {
> 	void operator()(double*, size_t) {}
> };
>
> std::vector<double> v(10000, uninitialized());
> // use v at your own risk here
>
> As Peter said, could provide an excellent interface to legacy C code.
> Though it may require some gymnastics to map to the C interface,
> especially when there are multiple arrays.
>
> 3.  This doesn't have the allocator compatibility problems of passing
> ownership of an array.
>
> 4.  The standard would not officially sanction something like
> uninitialized_flag, and yet people can still easily manage it if they
> want to.

5.  This needs a do-the-right-thing clause <sigh>.  Consider:

std::vector<double> v(10000UL, 0);

This will match:

template<class F> vector::vector(size_type n, F f);

instead of:

vector(size_type, const value_type&);

While implementing the "do-the-right-thing clause" is certainly doable.  
It is also certainly a pain in the rear.  This would be another elegant 
use for restricted templates:

vector(size_type n, const value_type& x = T(), const Allocator& = 
Allocator());

template <class It
    : !(is_convertible<It, size_type>::value &&
        is_convertible<It, value_type>::value)>
vector(It first, It last, const Allocator& = Allocator());

template <class F : !is_convertible<F, value_type>::value>
vector(size_type n, F init, const Allocator& = Allocator());

...

-Howard