shared-ptr

This answer cites N4082 , which shows that the upcoming changes to std::shared_ptr will allow both T[] and T[N] variants: Unlike the unique_ptr partial specialization for arrays, both shared_ptr<T[]> and shared_ptr<T[N]> will be valid and both will result in delete[] being called on the managed array of objects. template<class Y> explicit shared_ptr(Y* p); Requires : Y shall be a complete type. The expression delete[] p , when T is an array type, or delete p , when T is not an array type, shall be well-formed, shall have well defined behavior, and shall not throw exceptions. When T is U[N] , Y

I have a fairly complex multi threaded application (server) that from time to time will crash due to an assert: /usr/include/boost/smart_ptr/shared_ptr.hpp:418: T* boost::shared_ptr< <template-parameter-1-1> >::operator->() const [with T = msg::Player]: Assertion `px != 0' failed. I have been unable to pinpoint the cause and was wondering if this is a problem with boost::shared_ptr or it is me? I tried g++ 4.4.3-4ubuntu5 and llvm-g++ (GCC) 4.2.1 with optimization and without optimization and libboost1.40-dev (= 1.40.0-4ubuntu4). There should be no problem with using boost::shared_ptr as long

EDIT: Solved, my mistake; explained in my answer. I have this: std::vector < boost::shared_ptr < Entity > > entities; and I try to expose it through SWIG like this: %include "boost_shared_ptr.i" %include "std_vector.i" %shared_ptr(Entity) %include <Entity.h> namespace std { %template(EntityVector) vector<boost::shared_ptr<Entity> >; }; %include <TheFileWithEntities.h> However, in Python entities ends up being a tuple: import MyModule print type(MyModule.cvar.entities) # Output: (type 'tuple') I've Googled for this, but could not find any concrete examples on how to wrap this. One page gave a

I am trying to make my own implementation of shared_ptr . I have problems with make_shared . The main feature of std::make_shared that it allocates counter block and object in continuous block of memory. How I can do the same? I tried do something like that: template<class T> class shared_ptr { private: class _ref_cntr { private: long counter; public: _ref_cntr() : counter(1) { } void inc() { ++counter; } void dec() { if (counter == 0) { throw std::logic_error("already zero"); } --counter; } long use_count() const { return counter; } }; template<class _T> struct _object_and_block { _T object;

This question already has an answer here: What is the usefulness of `enable_shared_from_this`? 6 answers I am new to C++11 and I came across enable_shared_from_this. I do not understand what it is trying to achieve? So I have a program that uses enable_shared_from_this. struct TestCase: enable_shared_from_this<TestCase> { std::shared_ptr<testcase> getptr() { return shared_from_this(); } ~TestCase() { std::cout << "TestCase::~TestCase()"; } }; int main() { std::shared_ptr<testcase> obj1(new TestCase); std::shared_ptr<testcase> obj2 = obj1->getptr(); // The above can be re written as below //

std::shared_ptr is guaranteed to be thread-safe. I don't know what mechanism the typical implementations use to ensure this, but surely it must have some overhead. And that overhead would be present even in the case that your application is single-threaded. Is the above the case? And if so, does that means it violates the principle of "you don't pay for what you don't use", if you aren't using the thread-safety guarantees? If we check out cppreference page for std::shared_ptr they state the following in the Implementation notes section: To satisfy thread safety requirements, the reference

I have a base class with a pointer member. I would have to make an educated guess to determine whether it should be an unique_ptr or a shared_ptr . None of them seems to solve my particular use case. class Base { public: Base(): pInt(std::unique_ptr<int>(new int(10))) {}; virtual std::unique_ptr<int> get() = 0; //Base(): pInt(std::shared_ptr<int>(new int(10))) {}; // Alternate implementation //virtual std::shared_ptr<int> get() = 0; // Alternate implementation private: std::unique_ptr<int> pInt; //std::shared_ptr<int> pInt; // Alternate implementation }; The base class has been derived onto