On Aug 6, 2004, at 5:04 PM, Rob Stewart wrote:
Line 1b is a means to make construction from raw pointers more apparent, which is good, I agree. Note that your version can be rewritten like this, too:
shared_ptr<Widget> p(rawptr(new Widget(a, b)));
Note, however, that "rawptr" is rather terse for something you're trying to call attention to. How about "from_raw_ptr" or "from_raw_pointer?"
Somehow it has got stuck in my head that this should be shared_pointer_cast<>, but I'm having trouble justifying it, other than that it would look nice next to the dynamic_pointer_cast<> and so forth. shared_ptr<Widget> p = shared_ptr_cast<Widget>(new Widget); A little wordy, but if you want the event to stand out as Rob suggests, that would do it. In this case it would be handy: Base *someFactory(int typetomake); shared_ptr<Derived> d = shared_ptr_cast<Derived>(someFactory(DERIVED)); I also like the ability to assign to NULL. To me it looks pretty obviously like the right thing to do... -t
4. Most importantly, all raw pointers that are assigned to smart pointers must go through the rawptr() function (or rawptr_t<T> type), always making it "explicit". The problem in the example presented earlier, is therefore eliminated.
Right.
6. The only obvious problem I see, is the backward compability issue, although it still support the "unprotected but powerful pointer constructor approach", with a slightly different syntax.
The standardized version doesn't have to worry about backward compatiblity, fortuntely, so these ideas could be made part of that version, even if there is difficulty making the change to boost::smart_ptr. The interesting thing is that these changes could be made an extension to the current boost::smart_ptr so that safer usage is possible, just not required.
Implementation for shared_ptr =============================
rawptr.hpp (new file): --------------------- namespace boost {
template <class T> class rawptr_t { public: explicit rawptr_t(T * p) : px(p) {} T* get() const { return px; } private: rawptr_t& operator=(const rawptr_t&); T* px; };
Why not just:
template <typename T> struct rawptr_t { T * p_; };
You started with a raw pointer, and you're just trying to give it a special type recognized by shared_ptr. Why clutter it with the rest of the baggage?
-- Rob Stewart stewart@sig.com Software Engineer http://www.sig.com Susquehanna International Group, LLP using std::disclaimer; _______________________________________________ Unsubscribe & other changes: http://lists.boost.org/mailman/listinfo.cgi/boost