--- Gregory Colvin <[EMAIL PROTECTED]> wrote:
shared_ptr doesn't allocate the data, it only deletes it, which is the job of the
current deleter parameter. And the counter type is by design not part of the
shared_ptr type, so it doesn't belong as parameter to the shared_ptr template.
See:
http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/boost/boost/boost/ shared_ptr.hpp
So you what you might want is to add something more like this to shared_ptr:
template<typename Data, typename Deleter, template<class Counter> class Allocator> shared_ptr( Data*, Deleter, const Allocator<boost::detail::sp_counted_base_impl<Data*, Deleter> >& );
The idea being that you can use this constructor to get complete control over how
a particular shared_ptr manages memory.
In this solution, there are some issues with who controls the instances of the allocator that allocates Data and instances that delete the Data.
Which issues concern you?
But I guess it is not big deal as soon as people understand it. If are to use template template parameters,
Yes, the template template parameter is a pain. Probably better to take an arbitrary allocator object and rebind it:
template<class Y, class D, class A>
shared_ptr(T* p, D d, const A& a)
: px(p), pn(p, d, A::rebind<<detail::sp_counted_base_impl<Data*,D> >(a))
{
detail::sp_enable_shared_from_this(p, p, pn);
}
it would be nice to be able to define one allocator type for both counter and data.
template<typename Data, template<class> class Allocator> shared_ptr( Data*, Allocator<Data>, const Allocator<boost::detail::sp_counted_base_impl<Data*, Deleter> >& );
This constructor would conflict with the constructors that take a deleter, which must be a function pointer or function object, and which might not use an allocator.
But for the purpose of creating shared objects using an allocator you could instead use a factory function something like:
template<class Allocator,typename Data>
shared_ptr<T>
allocate_shared_data(const Data& data, Allocator allocator)
{
struct deleter {
Allocator a;
deleter(const Allocator& a) : a(a) {}
void operator()(Data* p) {
a.deallocate(p,1);
a.destroy(p);
}
};
Data* p = allocator.allocate(1);
allocator.construct(p,data);
return shared_ptr<Data>(p,deleter<Data>(allocator),allocator);
}_______________________________________________ Unsubscribe & other changes: http://lists.boost.org/mailman/listinfo.cgi/boost
