From: Gregory Colvin (gregory.colvin_at_[hidden])
Date: 2003-09-02 16:06:59
On Tuesday, Sep 2, 2003, at 13:18 America/Denver, E. Gladyshev wrote:
> --- Gregory Colvin <gregory.colvin_at_[hidden]> wrote:
>> Yep. I still think UserAllocator is a good default, and that where it
>> doesn't suffice there is some value to playing nicely with STL.
>>
>> So even when we come up with some beautiful new thing to do the
>> allocation job better, we will still need adaptors both ways, so that
>> one can get an allocator from an STL container and turn it in to one
>> of our new things, or take one of our new things and turn it into an
>> allocator to use in an STL container.
>
> Am I right in trying to summarize your suggestion about UserAllocator?
>
>
> If you want to parametrize how a boost class manages memory,
> use UserAllocator parameter.
Unless you need the standard Allocator interface.
> 1. The allocator parameter should implement the UserAllocator
> interface.
> 2. All instances of UserAllocator must be equal and stateless.
The Boost pools use UserAllocator only as a type parameter. It is not
required to be constructible or comparable.
> 3. If your class is using STL containers, use boost::memory::allocator
> adapter (see bellow).
Why not just use std::allocator?
> 4. To construct/destroy objects, use boost::memory::construct/destroy.
See below.
> 5. Avoid using explicit references to allocators.
>
> ... Usage example:
> ==============
> template< typename T, typename UserAllocator =
> boost::default_user_allocator_new_delete >
> class X
> {
What if you want X to use the same allocator as some other STL container
constructed with a non-Boost allocator? That would be difficult unless
you have
template<typename T, class StdAllocator = std::allocator<T> >
struct X {
X(const StdAllocator&);
Also, it might sometimes be desirable, as it is for shared_ptr, to
defer the choice of allocator until construction time:
template<typename T>
struct X {
template<class StdAllocator = std::allocator<T> >
X(const StdAllocator&);
Or, if UserAllocator suffices:
template<typename T>
struct X {
template<class UserAllocator> X();
> T* _p;
Leading underscores are a no-no.
> std::vector<T, boost::memory::allocator<T, UserAllocator> > _v;
>
> X()
> {
> _p = boost::memory::construct<T, UserAllocator>( 1 )
How to pass arguments to T's constructor? Better just
p = new(UserAllocator::malloc(sizeof T)) T(...)
> }
> ~X()
> {
> if( _p )
> boost::memory::destroy<T, UserAllocator>( _p, 1 );
In which case, why not just
p->~T(), UserAllocator::free(p);
?
> }
> };
>
> Eugene