smart-pointers

I am currently in a situation like: struct A { shared_ptr<B> b; }; struct B { shared_ptr<A> a; }; //... shared_ptr<A> a(new A()); shared_ptr<B> b(new B()); a->b(b); b->a(a); I know this won't work, because the references would continue to point to each other. I've also been told that weak_ptr solves this issue. However, weak_ptr has no get or -> overload. I've heard mentions of 'use lock() ', but can anyone give code examples of how to do this correctly? Come on now. http://boost.org/doc/libs/1_42_0/libs/smart_ptr/weak_ptr.htm ^^^^^ EXAMPLE IS RIGHT THERE ^^^^^^ DAMN! I think the bigger issue

I cannot figure this out.. Looks like I'm missing something simple? What do I put in MakePointToSameValue so that at point (1) both b.ptr and c.ptr point to the same as a.ptr in other words, a.ptr.get() == b.ptr.get() == c.ptr.get() the value originally pointed to by b.ptr and c.ptr gets deleted ? struct Test { public: Test( int val ) : ptr( std::make_shared< int >( val ) ) { } void MakePointToSameValue( Test& other ) { //what do I put here? //other.ptr = this->ptr; //doesn't do it } private: std::shared_ptr< int > ptr; }; Test a( 0 ); Test b( 5 ); Test c( b ); b.MakePointToSameValue( a ); //

Thinking of a way how to best approach the following design (pseudo C++ code): class Display { public: Bitmap GetBitmap(uint16 width, uint16 height); private: // A list of active bitmaps std::set<Bitmap> bitmaps; } ... where Display is a factory (and sole owner) for Bitmap objects. Display also has to track all the allocated bitmaps within a std::set container and may choose to invalidate/delete them at any time (like in a fullscreen switch). So essentially a Bitmap is a weak resource handle and whoever holds the handle will have to check if it is valid before using it. My theoretical solution

Is there a concise, generic way to convert a std container (such as vector ) of regular/dumb pointers: vector< T* > to, for instance, boost::shared_ptr ?: vector< boost::shared_ptr<T> > I thought I could pull it off using vector 's range constructor: vector< T* > vec_a; ... vector< boost::shared_ptr<T> > vec_b( vec_a.begin(), vec_a.end() ); but that refused to compile (Visual Studio 2008). EDIT: Test code: void test() { vector< int* > vec_a; vector< boost::shared_ptr<int> > vec_b( vec_a.begin(), vec_a.end() ); } Compilation errors: 1>c:\Program Files (x86)\Microsoft Visual Studio 9.0\VC

I need to deal with two struct addrinfo pointers. Since I'm coding in C++(11), I've to make my code exception-safe. Indeed, my costructors may throw a runtime_error . When you don't need that kind of struct anymore, you should call freeaddrinfo in order to free the list inside the struct. Please consider the following code: #include <memory> #include <netdb.h> class SomeOtherClass { public: SomeOtherClass() : hints(new addrinfo), result(new addrinfo) { /*stuff*/ } ~SomeOtherClass() { freeaddrinfo(result.get()); } // bad things will happen private: std::unique_ptr<addrinfo> hints, result; };

std::shared_ptr needs to allocate a control block on the heap which holds the reference count. There was another approach I learnt from http://ootips.org/yonat/4dev/smart-pointers.html which keeps all the references in a doubly linked list. It doesn't need additional allocations nor a counter but the reference object itself is larger. Is there a benchmark or any clear reason showing one implementation is better than the others? The standard does in theory allow a linked list to be used, but because copying a shared_ptr must be threadsafe it would be harder to implement that with a linked list.