How to implement make_unique function in C++11? [duplicate]

by

Version by Stephan T. Lavavej (also known by STL) who originally proposed adding this function to C++14

#include <cstddef>
#include <memory>
#include <type_traits>
#include <utility>

namespace std {
    template<class T> struct _Unique_if {
        typedef unique_ptr<T> _Single_object;
    };

    template<class T> struct _Unique_if<T[]> {
        typedef unique_ptr<T[]> _Unknown_bound;
    };

    template<class T, size_t N> struct _Unique_if<T[N]> {
        typedef void _Known_bound;
    };

    template<class T, class... Args>
        typename _Unique_if<T>::_Single_object
        make_unique(Args&&... args) {
            return unique_ptr<T>(new T(std::forward<Args>(args)...));
        }

    template<class T>
        typename _Unique_if<T>::_Unknown_bound
        make_unique(size_t n) {
            typedef typename remove_extent<T>::type U;
            return unique_ptr<T>(new U[n]());
        }

    template<class T, class... Args>
        typename _Unique_if<T>::_Known_bound
        make_unique(Args&&...) = delete;
}

EDIT: updated code to the N3656 standard revision

More Related Contents:

  1. Differences between std::make_unique and std::unique_ptr with new
  2. error::make_unique is not a member of ‘std’
  3. Raw pointer lookup for sets of unique_ptrs
  4. Implementation C++14 make_integer_sequence
  5. make_unique and perfect forwarding
  6. Differences between unique_ptr and shared_ptr [duplicate]
  7. “Downcasting” unique_ptr to unique_ptr
  8. Copy constructor for a class with unique_ptr
  9. Advantages of using std::make_unique over new operator [duplicate]
  10. Overload resolution between object, rvalue reference, const reference
  11. Pointers in c++ after delete
  12. C++11: Correct std::array initialization?
  13. Pass by value vs pass by rvalue reference
  14. How do I use unique_ptr for pimpl?
  15. Why are lambda expressions not allowed in an unevaluated operands but allowed in the unevaluated portions of constant expressions?
  16. Default, value and zero initialization mess
  17. Is #pragma once part of the C++11 standard?
  18. So can unique_ptr be used safely in stl collections?
  19. Exception safety and make_unique
  20. Are notes and examples in the core language specification of the C++ Standard non-normative?
  21. Check traits for all variadic template arguments
  22. Calling initializer_list constructor via make_unique/make_shared
  23. Should I use shared_ptr or unique_ptr
  24. How to immediately invoke a C++ lambda?
  25. unique_ptr and OpenSSL’s STACK_OF(X509)*
  26. How can I compile C++11 code with Orwell Dev-C++?
  27. Why is `make_unique` disallowed?
  28. stl container with std::unique_ptr’s vs boost::ptr_container
  29. Is there a way to write make_unique() in VS2012?
  30. Does C++11 unique_ptr and shared_ptr able to convert to each other’s type?

Leave a Comment