Re: [Boost-users] Suggestion for boost`s smart pointers
-----Original Message----- From: boost-users-bounces@lists.boost.org [mailto:boost-users-bounces@lists.boost.org] On Behalf Of Sohail Somani
The deleter feature in shared_ptr is very useful for raii with any kind of resource (variables, functions, objects, etc.). Having it in scoped_ptr will offer the same advantage for noncopyable pointers.
Thank you.
+1 from me too but I think the reason is that people wanted sizeof(scoped_ptr<T>) to be sizeof(T *) (or they don't want it to change)
A part solution could be a second template parameter but of course there can be no state.
wow, this seems like a great idea, a scoped_ptr with deleter would be v.useful. mark On 11/29/06, Sohail Somani <s.somani@fincad.com> wrote:
-----Original Message----- From: boost-users-bounces@lists.boost.org [mailto:boost-users-bounces@lists.boost.org] On Behalf Of Sohail Somani
The deleter feature in shared_ptr is very useful for raii with any kind of resource (variables, functions, objects, etc.). Having it in scoped_ptr will offer the same advantage for noncopyable pointers.
Thank you.
+1 from me too but I think the reason is that people wanted sizeof(scoped_ptr<T>) to be sizeof(T *) (or they don't want it to change)
A part solution could be a second template parameter but of course there can be no state. _______________________________________________ Boost-users mailing list Boost-users@lists.boost.org http://lists.boost.org/mailman/listinfo.cgi/boost-users
-----Original Message----- From: boost-users-bounces@lists.boost.org [mailto:boost-users-bounces@lists.boost.org] On Behalf Of Sohail Somani Sent: Tuesday, November 28, 2006 4:44 PM
-----Original Message----- From: boost-users-bounces@lists.boost.org [mailto:boost-users-bounces@lists.boost.org] On Behalf Of Sohail Somani
The deleter feature in shared_ptr is very useful for raii with any kind of resource (variables, functions, objects, etc.). Having it in scoped_ptr will offer the same advantage for noncopyable pointers.
Thank you.
+1 from me too but I think the reason is that people wanted sizeof(scoped_ptr<T>) to be sizeof(T *) (or they don't want it to change)
A part solution could be a second template parameter but of course
there
can be no state.
I have put together an option based on Andrei Alexandrescu's policy based design. It may take a little time to read, as I modified a copy of scoped_ptr.hpp. What I did was add a second template parameter (called deleter) and inherited scoped_ptr from this. The default deleter adds no state, and simply deletes the pointer, just like scoped_ptr always has. On most compilers, it will not change the size of the shared_ptr, and any apparent overhead should be optimized away. I have also supplied an assignable deleter, which will act much like shared_ptr's custom deleters. If you select this deleter, it will increase the size of the scoped_ptr to store the pointer to the custom deleter. This also adds member functions to set and clear the deleter, and even enables new versions of the constructer and reset function that take the deleter as a second parameter. It is also somewhat straightforward to add new deleter policies. This could be useful if you wanted to use a custom deleter without increasing the size of the scoped_ptr. Here is a skeleton for a new deleter policy: template<class T> class default_deleter { public: /*Any public functions you declare will be added to the scoped_ptr's interface*/ protected: typedef int delete_parm_type; /*This will become the second parameter for the two-argument constructor and reset function*/ default_deleter() {} /*Protected constructor because this class to worthless on its own*/ ~default_deleter() {} /*Protected destructor to ensure scoped_ptr must be properly destroyed*/ void policy_delete (T* ptr) { /*Your delete code here*/ } void swap(default_deleter & b) // never throws { /*Any code needed to swap two deleters here*/ } private: default_deleter (delete_parm_type); /*Make this protected if you want to use the two-argument constructor and reset function*/ //Declare these private to prevent copying default_deleter(default_deleter const &); default_deleter & operator=(default_deleter const &); };
On Nov 29, 2006, at 12:50 PM, Andrew Holden wrote:
I have put together an option based on Andrei Alexandrescu's policy based design. It may take a little time to read, as I modified a copy of scoped_ptr.hpp. What I did was add a second template parameter (called deleter) and inherited scoped_ptr from this.
If instead of inheriting from D, you contain a compressed_pair<T*, D>, you'll get the same size savings and be able to support function pointers as deleters. With a little more work (in your constructors mainly) you can support D& types as a deleter. D& types are really handy for transferring pointer ownership from one object to another when there is a custom deleter of unknown type. Of course since you're working with scoped_ptr, perhaps you're not interested in this use case. But just in case you are: template<class T, class D> class A { ... void foo(T* p); private: T* p_; D deleter_; ... }; // A::foo establishes ownership of p, but // must acquire other resources to do so. A local // unique_ptr is used as an aid to hold on to p while // those other resources are acquired. template<class T, class D> void A<T, D>::foo(T* p) { // Establish preliminary ownership without requiring // a copy of the deleter D std::unique_ptr<T, D&> hold(p, deleter_); // no throw // acquire resources // if throws, // ... // deleter_(p) executed // transfer ownership to A p_ = hold.release(); // no throw } -Howard
participants (4)
-
Andrew Holden -
Howard Hinnant -
mark cox -
Sohail Somani