you have two copies of shared_ptr<A> in this case, one is the sharedptr variable and the other as an element in the vector. do this instead test.push_back(std::move(sharedptr)); note now the original sharedptr has it’s internal moved and no longer usable. The other thing is don’t do anything at all, this is a perfectly valid usage … Read more
scoped_ptr is very good for this purpose. But one has to understand its semantics. You can group smart pointers using two major properties: Copyable: A smart pointer can be copied: The copy and the original share ownership. Movable: A smart pointer can be moved: The move-result will have ownership, the original won’t own anymore. That’s … Read more
You can’t do it directly, but there are a couple of ways to simulate it, with the help of the Non-Virtual Interface idiom. Use covariance on raw pointers, and then wrap them struct Base { private: virtual Base* doClone() const { … } public: shared_ptr<Base> Clone() const { return shared_ptr<Base>(doClone()); } virtual ~Base(){} }; struct … Read more
Even in C++11, raw pointers are still perfectly valid as non-owning references to objects. In your case, you’re saying “Let’s assume the textures are guaranteed to outlive their pointers.” Which means you’re perfectly safe to use raw pointers to the textures in the game objects. Inside the texture manager, store the textures either automatically (in … Read more
shared_ptr is more heavyweight than scoped_ptr. It needs to allocate and free a reference count object as well as the managed object, and to handle thread-safe reference counting – on one platform I worked on, this was a significant overhead. My advice (in general) is to use the simplest object that meets your needs. If … Read more
You can’t do this with compile-time checks at all. The C++ type system is lacking any way to reason about when an object goes out of scope, is moved, or is destroyed — much less turn this into a type constraint. What you could do is have a variant of unique_ptr that keeps a counter … Read more
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 smart pointer, because the reference counts will be stored adjacent in memory to the object itself, improving locality of reference and cache usage. It also provides std::enable_shared_from_this which allows you … Read more
Because std::make_unique<int[]>(100) performs value initialization while new int[100] performs default initialization – In the first case, elements are 0-initialized (for int), while in the second case elements are left uninitialized. Try: int *p = new int[100](); And you’ll get the same output as with the std::unique_ptr. See this for instance, which states that std::make_unique<int[]>(100) is … Read more
The full name of the rule is the rule of 3/5/0. It doesn’t say “always provide all five”. It says that you have to either provide the three, the five, or none of them. Indeed, more often than not the smartest move is to not provide any of the five. But you can’t do that … Read more
It seems to me that Rc<> should just consist of a pointer, which is a fixed size, so the type itself should be Sized and hence Copy, right? This is not quite true. Rc is short for Reference Counted. This means that the type keeps track of how many references point to the owned data. … Read more