On Jul 15, 2008, at 3:28 AM, Johan Torp wrote:
So scoped_ptr's type tells us something and there is probably lots of code out there which wants to convey this information. Therefor we shouldn't change it's semantics. Also, scoped_ptr and auto_ptr are more lightweight since they do not have the extra level of indirection that a custom deleter requires.
I agree that scoped_ptr provides semantics that unique_ptr doesn't and so should not be removed from boost. However I did want to clarify one bit: sizeof(unique_ptr<int>) == sizeof(auto_ptr<int>) == sizeof(scoped_ptr<int>) == sizeof(int*). And unique_ptr<int> doesn't allocate any extra memory on the heap (unlike shared_ptr, and just like scoped_ptr and auto_ptr). The deleter of unique_ptr is a "static deleter". This is in contrast to shared_ptr's "dynamic deleter". The static deleter requires no overhead unless it contains state (the default_delete is stateless). Simplified: template <class T> class scoped_ptr { T* ptr_; public: explicit scoped_ptr(T* p) : ptr_(p) {} ... }; template <class T, class D = default_delete<T>> class unique_ptr { compressed_pair<T*, D> ptr_; // or a future implementation of tuple<T*, D> ! ;-) public: explicit unique_ptr(T* p) : ptr_(p) {} unique_ptr(T* p, D&& d) : ptr_(p, std::move(d)) {} ... }; template <class T> class shared_ptr { __shared_ptr_base* ptr_; public: template <class Y> explicit shared_ptr(Y* p) : ptr_(new __shared_ptr_imp<Y, default_delete<Y>>(p)) {} template <class Y, class D> shared_ptr(Y* p, D d) : ptr_(new __shared_ptr_imp<Y, D>(p, d)) {} ... }; -Howard