smart-pointers

Apologies for the long question, but some context is necessary. I have a bit of code that seems to be a useful pattern for the project I'm working on: class Foo { public: Foo( int bar = 1 ); ~Foo(); typedef std::shared_ptr< Foo > pointer_type; static pointer_type make( int bar = 1 ) { return std::make_shared< Foo >( bar ); } ... } As you can see, it provides a straightforward way of constructing any class as a PointerType which encapsulates a shared_ptr to that type: auto oneFoo = Foo::make( 2 ); And therefore you get the advantages of shared_ptr without putting references to make_shared and

I've these plain C functions from a library: struct SAlloc; SAlloc *new_salloc(); void free_salloc(SAlloc *s); Is there any way I can wrap this in C++ to a smart pointer (std::unique_ptr), or otherwise a RAII wrapper ? I'm mainly curious about the possibilities of the standard library without creating my own wrapper/class. Yes, you can reuse unique_ptr for this. Just make a custom deleter. struct salloc_deleter { void operator()(SAlloc* s) const { free_salloc(s); // what the heck is the return value for? } } using salloc_ptr = std::unique_ptr<SAlloc, salloc_deleter>; I like R. Martinho

I'm creating a GUI in my C++ application and I have a class called GUIObject which is base class for all other components, like for example Button , CheckBox , Window etc. I also have a class GUIObjectsStorage , which consists of all GUIObject s that are created. So far I've been working with raw pointers, so I just had this constructor for GUIObject class: GUIObject::GUIObject() : { GUIObjectsStorage::Instance().addObject(this); } And it was ok for my needs, because whenever I wanted to access specific object, I just took it from GUIObjectsStorage . But now I'm trying to move into use of

When I try to use a static const to initialize a unique_ptr , I get an "undefined reference" error. However, when I new a pointer using the same constant, the symbol seems to be magically defined. Here is a simple program that reproduces the error: Outside_library.h class Outside_library { public: static const int my_const = 100; }; main.cpp #include "Outside_library.h" #include <iostream> #include <memory> class My_class { public: My_class(int num) { m_num = num; }; virtual ~My_class(){}; private: int m_num; }; int main(int, char* []) { My_class* p_class = new My_class(Outside_library::my

boost::intrusive_ptr requires intrusive_ptr_add_ref and intrusive_ptr_release to be defined. Why isn't a base class provided which will do this? There is an example here: http://lists.boost.org/Archives/boost/2004/06/66957.php , but the poster says "I don't necessarily think this is a good idea". Why not? Update: I don't think the fact that this class could be misused with Multiple Inheritance is reason enough. Any class which derives from multiple base classes with their own reference count would have the same issue. Whether these refcounts are implemented via a base class or not makes no

In C++/CLI , you can use native types in a managed class by it is not allowed to hold a member of a native class in a managed class : you need to use pointers in that case. Here is an example : class NativeClass { .... }; public ref class ManagedClass { private: NativeClass mNativeClass; // Not allowed ! NativeClass * mNativeClass; // OK auto_ptr<NativeClass> mNativeClass; //Not allowed ! boost::shared_ptr<NativeClass> mNativeClass; //Not allowed ! }; Does anyone know of an equivalent of shared_ptr in the C++/CLI world? Edit: Thanks for your suggestion, "1800-Information". Following your

I commonly come across the need to create arrays or vectors of polymorphic objects. I'd usually prefer to use references, rather than smart pointers, to the base class because they tend to be simpler. Arrays and vectors are forbidden from containing raw references, and so I've tended to use smart pointers to the base classes instead. However, there is also the option to use std::reference_wrapper instead: https://en.cppreference.com/w/cpp/utility/functional/reference_wrapper From what I can tell from the documentation, this is what one of its intended uses is, but when the topic of arrays