smart-pointers

I often need to deal with dynamically-allocated arrays in C++, and hence rely on Boost for scoped_array, shared_array, and the like. After reading through Stroustrup's C++11 FAQ and the C++11 Reference Wiki , I could not find a suitable replacement for these dynamic array wrappers that is provided by the C++11 standard. Is there something that I have overlooked, or do I have to continue relying on Boost? Thank you very much for your help! There is a specialization of unique_ptr , like unique_ptr<T[]> . #include <iostream> #include <memory> struct test { ~test() { std::cout << "test::dtor" <<

I'm thinking of using boost::weak_ptr to implement a pool of objects such that they will get reaped when nobody is using one of the objects. My concern, though, is that it's a multi-threaded environment, and it seems there's a race condition between the last shared_ptr to an object going out of scope and a new shared_ptr being constructed from the weak_ptr. Normally, you'd protect such operations with lock or something; however, the whole point here is that you don't know when the shared_ptr might be going out of scope. Am I misunderstanding something about boost::shared_ptr and boost::weak

I'm just toying around with the smart pointers in the upcoming new c++ standard. However I fail to grasp the usage of the shared_from_this function. Here is what I have: #include <iostream> #include <memory> class CVerboseBornAndDie2 : public std::enable_shared_from_this<CVerboseBornAndDie2> { public: std::string m_Name; CVerboseBornAndDie2(std::string name) : m_Name(name) { std::cout << m_Name << " (" << this << ") is born!" << std::endl; } virtual ~CVerboseBornAndDie2() { std::cout << m_Name << " (" << this << ") is dying!" << std::endl; } }; int main(){ CVerboseBornAndDie2* vbad = new

Just recently I switched the language of my project to use C++ from C. With C, I used malloc and after that I check if malloc was successful but with C++, I use 'new' to allocate memory and I would like to know how you would normally check the memory allocation failure. From my google search, I saw nothrow like the following. char *buf = new (nothrow)char[10]; I also saw the following. try{} catch(bad_alloc&) {} But what about the following? I am using some of chrome library routines to use smart pointers. For instance, I have the code as follows. scoped_array<char> buf(new char[MAX_BUF]); It

Does C++11 have something equivalent to boost::intrusive_ptr ? My problem is that I have a C-style interface over my C++ code. Both sides of the interface can use C++, but exposing the C interface is required for compatibility reasons. I cannot use std::shared_ptr because I have to manage the object through two (or more) smart pointers. I am unable to figure out a solution with something like boost::intrusive_ptr . Does c++11 have something equivalent to boost::intrusive_ptr? No. It does have std::make_shared which means std::shared_ptr is almost (see note below) as efficient as an intrusive