5 ms·
"everything touched by shared_ptr needs to be under the shared_ptr regime or carefully bridged to it" Well, yes. That's sort of the point. You can write old-
by timr 15y ago
"everything touched by shared_ptr needs to be under the shared_ptr regime or carefully bridged to it"
Well, yes. That's sort of the point. You can write old-style C++, or your can write modern C++, but the library designers are trying to make you think carefully when you're doing both, because that is a source of memory lifecycle bugs. Using the boost (now standard) pointers universally tends to dramatically reduce the chances of memory-related bugs in C++ code.
Not using shared_ptr is a code smell. Sometimes you have to do it, but if you're avoiding the use of the smart pointer classes in blue sky code, you're doing something wrong.
- tptacek 15y agoThis breaks down as soon as you have to integrate 3rd party code.
- timr 15y agoIt doesn't "break"...you just have to think about what you're doing. Which, again, is the point. If some external code is passing you pointers, then using shared_ptr is exactly the wrong thing to do, because you (presumably) don't own the memory. And if you do own the memory, there's no problem putting it in a shared_ptr. The fact that you can't blindly stuff everything into a shared_ptr is a feature, not a bug.
- alexgartrell 15y agoThe main thing that sucks about shared_ptr's is that they break C++'s limited support for covariance. For example class A { ... }; class B : public A { ... }; // Totally works class AFactory { public: virtual A* makeOne(); } class BFactory : public AFactory { public: virtual B* makeOne(); } // totally doesn't class SharedAFactory { public: virtual boost::shared_ptr<A> makeOne(); }; class SharedBFactory { public: virtual boost::shared_ptr<B> makeOne(); }; Also, from a performance perspective, locking the memory bus to do atomic operations on a shared_ptr totally blows when you're expected to turn a request around in a few microseconds.
- timr 15y agoI'll grant you the larger point that inferring relationships by template value type can be a pain. But this example is kind of bad. First off, I assume you meant to derive SharedBFactory from SharedAFactory? Otherwise, it works fine. If not, the only problem here is that C++ won't let you have a virtual function override that only differs by return type. And since it can't tell that shared_ptr<A> and shared_ptr<B> are related by value_type, it complains (this is the larger point that I granted you earlier). But the type theatrics are hiding a bigger problem.... In this example, you can either fix the type error by making makeOne() return a boost::shared_ptr<A> in all factories (in which case, you really do want a polymorphic interface), or you can make a new function that returns a different pointer type (in which case, you don't). The type system here is doing you a favor, and telling you that your design is bogus -- you shouldn't be creating a polymorphic factory interface that returns different types (because that isn't actually polymorphic, is it?) This isn't totally academic: I find that in nearly all type-error situations like this one, the real problem can be traced back to sloppy coding. "locking the memory bus to do atomic operations on a shared_ptr totally blows when you're expected to turn a request around in a few microseconds." There's always a cost to reference counting, and therefore, it's not always appropriate. That said, the only time you should be triggering atomic operations are on pointer copies and allocations. If you're doing allocations per request, kiss your microsecond response time goodbye -- the reference count overhead is the least of your worries. And you can avoid unnecessary pointer copies by passing shared_ptr<> objects by reference. With a small amount of care, it's possible to reduce shared_ptr<> overhead to essentially zero.
- MatthewCampbell 15y agoTheir polymorphic factory isn't returning "different types." They're both returning A. The derived one is just returning a specific type of A. If the shared "makeOne" returned naked pointer types A* and B* rather than shared_ptr, then this would all work correctly, thanks to C++'s covariant return type support. Covariant return types are a powerful feature in a language that doesn't support other forms of return type polymorphism. shared_ptrs function so similarly to pointers that it can be surprising when they don't support this behavior. Surprise and capability mismatch with pointers are strikes against shared_ptr. But not sufficient ones to stop me from using them.
- zvrba 15y agoI'm tired of marketing boost as "modern C++". Alexei Alexandrescu, the author of "Modern C++ design" book has since gone on greener pastures and got involved with the D language. He participated in the design of D, and wrote a book about it. Not using shared_ptr a code smell? If you're not able to keep track of your objects yourself, you should not be using C or C++. It's not that hard like you would like us believe. Also, apart from the cost of maintaining reference counts, shared_ptr makes an extra allocation for the control block. Unless you take care and use make_shared, you end up with allocations that are twice as slow. On a cynical side: Boost has become Dave Abrahams' business (1) He (and co.) have a vested interest in making you believe that the Boost-way is "the" way of writing "modern" (as defined by HIM and his followers) C++ code. I just wonder whether he had that much foresight, or just took the chance when he saw the opportunity. (1) I remember once asking about obtaining slides about fusion from a past BoostCon conference and got a blank "no". Slides were available only to the people who paid to attend the conference.
- timr 15y ago"Not using shared_ptr a code smell?" Yes. It's part of the C++ standard. All rants against Dave Abrahams and Boost aside, not using the standard library to do standard things is a code smell.
- zvrba 15y agoWhat "standard things"? shared_ptr is only one of many possible ways to keep track of object lifetimes. Rolling your own reference-counted smart pointer might be a code smell, but not choosing reference counting is far from that.