shared_ptr are the most complicated type of pointer ever: Ref counting takes time Multiple allocation (there are 3 parts: the object, the counter, the deleter) A number of virtual methods (in the counter and the deleter) for type erasure Works among multiple threads (thus synchronization) There are 2 ways to make them faster: use make_shared … Read more
You have to consider that std::shared_ptr is overall still a pointer (encapsulated in a pointer like class) and that it can indeed be constructed to internally be nullptr. When that happens, expressions like: ptr-> *ptr leads to undefined behavior. So, yeah, if you are expecting the pointer to also be nullptr, then you should check … Read more
I’ve been making some objects using the pimpl idiom, but I’m not sure whether to used shared_ptr or unique_ptr. Definitely unique_ptr or scoped_ptr. Pimpl is not a pattern, but an idiom, which deals with compile-time dependency and binary compatibility. It should not affect the semantics of the objects, especially with regard to its copying behavior. … Read more
Answer: don’t do it. It’s convenient for you and nobody else. Say what you mean.
Your suggestion (calling the shared_ptr<T> constructor with no argument) is correct. (Calling the constructor with the value 0 is equivalent.) I don’t think that this would be any slower than calling vec.push_back() with a pre-existing shared_ptr<T>, since construction is required in both cases (either direct construction or copy-construction). But if you want “nicer” syntax, you … Read more
As infrastructure I was using llvm/clang 3.0 along with the llvm std c++ library within XCode4. Well that appears to be your problem. The C++11 standard states the following requirements for make_shared<T> (and allocate_shared<T>), in section 20.7.2.2.6: Requires: The expression ::new (pv) T(std::forward(args)…), where pv has type void* and points to storage suitable to hold … Read more
You have two options to retrieve a reference to the object pointed to by a shared_ptr. Suppose you have a shared_ptr variable named ptr. You can get the reference either by using *ptr or *ptr.get(). These two should be equivalent, but the first would be preferred. The reason for this is that you’re really attempting … Read more
For future people struggling with a similar problem, the situation is that the compiler simply cannot find the type you are using (even if your Intelisense can find it). This can be caused in many ways: You forgot to #include the header that defines it. Your inclusion guards (#ifndef BLAH_H) are defective (your #ifndef BLAH_H … Read more
What you’re reading isn’t meaning what you think it means. First of all, try the msdn page for shared_ptr itself. Scroll down into the “Remarks” section and you’ll get to the meat of the issue. Basically, a shared_ptr<> points to a “control block” which is how it keeps track of how many shared_ptr<> objects are … Read more
When using reset() the parameter passed to reset need not be a managed object (nor can it be); whereas with = the right hand side must be a managed object. So these two lines give you the same end result: p = std::make_shared<int>(5); // assign to a newly created shared pointer p.reset(new int(5)); // take … Read more