How do I call ::std::make_shared on a class with only protected or private constructors?

by

This answer is probably better, and the one I’ll likely accept. But I also came up with a method that’s uglier, but does still let everything still be inline and doesn’t require a derived class:

#include <memory>
#include <string>

class A {
 protected:
   struct this_is_private;

 public:
   explicit A(const this_is_private &) {}
   A(const this_is_private &, ::std::string, int) {}

   template <typename... T>
   static ::std::shared_ptr<A> create(T &&...args) {
      return ::std::make_shared<A>(this_is_private{0},
                                   ::std::forward<T>(args)...);
   }

 protected:
   struct this_is_private {
       explicit this_is_private(int) {}
   };

   A(const A &) = delete;
   const A &operator =(const A &) = delete;
};

::std::shared_ptr<A> foo()
{
   return A::create();
}

::std::shared_ptr<A> bar()
{
   return A::create("George", 5);
}

::std::shared_ptr<A> errors()
{
   ::std::shared_ptr<A> retval;

   // Each of these assignments to retval properly generates errors.
   retval = A::create("George");
   retval = new A(A::this_is_private{0});
   return ::std::move(retval);
}

Edit 2017-01-06: I changed this to make it clear that this idea is clearly and simply extensible to constructors that take arguments because other people were providing answers along those lines and seemed confused about this.

More Related Contents:

  1. shared_ptr to an array : should it be used?
  2. Difference in make_shared and normal shared_ptr in C++
  3. Differences between unique_ptr and shared_ptr [duplicate]
  4. Why isn’t there a std::shared_ptr specialisation?
  5. Why do std::shared_ptr work
  6. Should we pass a shared_ptr by reference or by value?
  7. Passing shared pointers as arguments
  8. std::shared_ptr initialization: make_shared() vs shared_ptr(new Foo) [duplicate]
  9. Passing shared_ptr as shared_ptr
  10. Where is shared_ptr?
  11. std::shared_ptr thread safety explained
  12. Should I use shared_ptr or unique_ptr
  13. What is the difference between an empty and a null std::shared_ptr in C++?
  14. How do shared pointers work?
  15. Why would I std::move an std::shared_ptr?
  16. shared_ptr and weak_ptr differences
  17. Why does unique_ptr take two template parameters when shared_ptr only takes one?
  18. weak_ptr, make_shared and memory deallocation
  19. Does C++11 unique_ptr and shared_ptr able to convert to each other’s type?
  20. initializer_list and move semantics
  21. Why is the C++ initializer_list behavior for std::vector and std::array different?
  22. Can I use C++11 with Xcode?
  23. When is it necessary to use the flag -stdlib=libstdc++?
  24. Inferring the call signature of a lambda or arbitrary callable for “make_function”
  25. I cannot pass lambda as std::function
  26. Is the data in nested std::arrays guaranteed to be contiguous?
  27. constexpr const vs constexpr variables?
  28. Why is std::cout so time consuming?
  29. Does C++11 change the behavior of explicitly calling std::swap to ensure ADL-located swap’s are found, like boost::swap?
  30. Is it safe to reinterpret_cast an enum class variable to a reference of the underlying type?

Leave a Comment