Boost logo

Boost :

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& =

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());



Boost list run by bdawes at, gregod at, cpdaniel at, john at