smart-pointers

Just a conceptual question that I've been running into. In my current project it feels like I am over-using the boost smart_ptr and ptr_container libraries. I was creating boost::ptr_vectors in many different objects and calling the transfer() method to move certain pointers from one boost::ptr_vector to another. It is my understanding that it is important to clearly show ownership of heap allocated objects. My question is, would it be desirable to use these boost libraries to create heap-allocated members that belong to an object but then use normal pointers to these members via get() when

std::auto_ptr is broken in VC++ 8 (which is what we use at work). My main gripe with it is that it allows auto_ptr<T> x = new T(); , which of course leads to horrible crashes, while being simple to do by mistake. From an answer to another question here on stackoverflow: Note that the implementation of std::auto_ptr in Visual Studio 2005 is horribly broken. http://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=98871 http://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=101842 I want to use boost::scoped_ptr , for pointers that shouldn't pass

With shared_ptr you can use a custom deleter, like: auto fp = shared_ptr<FILE>( fopen("file.txt", "rt"), &fclose ); fprintf( fp.get(), "hello\n" ); and this will remember to fclose the file regardless of how the function exits. However, it seems a bit overkill to refcount a local variable, so I want to use unique_ptr : auto fp = unique_ptr<FILE>( fopen("file.txt", "rt"), &fclose ); however, that does not compile. Is this a defect? Is there a simple workaround? Im I missing something trivial? Should be unique_ptr<FILE, int(*)(FILE*)>(fopen("file.txt", "rt"), &fclose); since http://en

C++11 introduced reference-counted smart pointers, std::shared_ptr . Being reference counted, these pointers are unable to automatically reclaim cyclic data structures. However, automatic collection of reference cycles was shown to be possible, for example by Python and PHP . To distinguish this technique from garbage collection, the rest of the question will refer to it as cycle breaking . Given that there seem to be no proposals to add equivalent functionality to C++, is there a fundamental reason why a cycle breaker similar to the ones already deployed in other languages wouldn't work for

This should be trivial but I can't seem to find it (unless no such class exists!) What's the STL class (or set of classes) for smart pointers? UPDATE Thanks for the responses, I must say I'm surprised there's no standard implementation. I ended up using this one: http://archive.gamedev.net/reference/articles/article1060.asp With the exception of the already mentionned TR1 shared_ptr, there is no reference-counted pointer in STL. I suggest you use boost::shared_ptr (downloading boost will be enough, there is nothing to compile, its implementation is header-only). You may also want to have a

I have some code that currently uses raw pointers, and I want to change to smart pointers. This helps cleanup the code in various ways. Anyway, I have factory methods that return objects and its the caller's responsibility to manager them. Ownership isn't shared and so I figure unique_ptr would be suitable. The objects I return generally all derive from a single base class, Object . For example, class Object { ... }; class Number : public Object { ... }; class String : public Object { ... }; std::unique_ptr<Number> State::NewNumber(double value) { return std::unique_ptr<Number>(new Number(this

I've got a type which inherits from enable_shared_from_this<type> , and another type that inherits from this type. Now I can't use the shared_from_this method because it returns the base type and in a specific derived class method I need the derived type. Is it valid to just construct a shared_ptr from this directly? Edit: In a related question, how can I move from an rvalue of type shared_ptr<base> to a type of shared_ptr<derived> ? I used dynamic_cast to verify that it really was the correct type, but now I can't seem to accomplish the actual move. Once you obtain the shared_ptr<Base> , you