make_unique.h

Go to the documentation of this file.

// This is free and unencumbered software released into the public domain.

// Anyone is free to copy, modify, publish, use, compile, sell, or
// distribute this software, either in source code form or as a compiled
// binary, for any purpose, commercial or non-commercial, and by any
// means.

// In jurisdictions that recognize copyright laws, the author or authors
// of this software dedicate any and all copyright interest in the
// software to the public domain. We make this dedication for the benefit
// of the public at large and to the detriment of our heirs and
// successors. We intend this dedication to be an overt act of
// relinquishment in perpetuity of all present and future rights to this
// software under copyright law.

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
// OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.

// Implementation of C++14's make_unique for C++11 compilers.
//
// This has been tested with:
// - MSVC 11.0 (Visual Studio 2012)
// - gcc 4.6.3
// - Xcode 4.4 (with clang "4.0")
//
// It is based off an implementation proposed by Stephan T. Lavavej for
// inclusion in the C++14 standard:
//    http://isocpp.org/files/papers/N3656.txt
// Where appropriate, it borrows the use of MSVC's _VARIADIC_EXPAND_0X macro
// machinery to compensate for lack of variadic templates.
//
// This file injects make_unique into the std namespace, which I acknowledge is
// technically forbidden ([C++11: 17.6.4.2.2.1/1]), but is necessary in order
// to have syntax compatibility with C++14.
//
// I perform compiler version checking for MSVC, gcc, and clang to ensure that
// we don't add make_unique if it is already there (instead, we include
// <memory> to get the compiler-provided one). You can override the compiler
// version checking by defining the symbol COMPILER_SUPPORTS_MAKE_UNIQUE.
//
//
// ===============================================================================
// This file is released into the public domain. See LICENCE for more information.
// ===============================================================================

#pragma once

// If user hasn't specified COMPILER_SUPPORTS_MAKE_UNIQUE then try to figure out
// based on compiler version if std::make_unique is provided.
#if !defined(COMPILER_SUPPORTS_MAKE_UNIQUE)
#if defined(_MSC_VER)
// std::make_unique was added in MSVC 12.0
#if _MSC_VER >= 1800  // MSVC 12.0 (Visual Studio 2013)
#define COMPILER_SUPPORTS_MAKE_UNIQUE
#endif
#elif defined(__clang__)
// std::make_unique was added in clang 3.4, but not until Xcode 6.
// Annoyingly, Apple makes the clang version defines match the version
// of Xcode, not the version of clang.
#define CLANG_VERSION (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__)
#if defined(__APPLE__) && CLANG_VERSION >= 60000
#define COMPILER_SUPPORTS_MAKE_UNIQUE
#elif !defined(__APPLE__) && CLANG_VERSION >= 30400
#define COMPILER_SUPPORTS_MAKE_UNIQUE
#endif
#elif defined(__GNUC__)
// std::make_unique was added in gcc 4.9, for standards versions greater
// than -std=c++11.
#define GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
#if GCC_VERSION >= 40900 && __cplusplus > 201103L
#define COMPILER_SUPPORTS_MAKE_UNIQUE
#endif
#endif
#endif

#if defined(COMPILER_SUPPORTS_MAKE_UNIQUE)

// If the compiler supports std::make_unique, then pull in <memory> to get it.
#include <memory>

#else

// Otherwise, the compiler doesn't provide it, so implement it ourselves.

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

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

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

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

//
// template< class T, class... Args >
// unique_ptr<T> make_unique( Args&&... args);
//

#if defined(_MSC_VER) && (_MSC_VER < 1800)

// Macro machinery because MSVC 11.0 doesn't support variadic templates.
// The _VARIADIC_EXPAND_0X stuff is defined in <xstddef>
#define _MAKE_UNIQUE(TEMPLATE_LIST, PADDING_LIST, LIST, COMMA, X1, X2, X3, X4)                                         \
  template <class _Ty COMMA LIST(_CLASS_TYPE)>                                                                         \
  inline typename _Unique_if<_Ty>::_Single_object make_unique(LIST(_TYPE_REFREF_ARG))                                  \
  {                                                                                                                    \
    return unique_ptr<_Ty>(new _Ty(LIST(_FORWARD_ARG)));                                                               \
  }

_VARIADIC_EXPAND_0X(_MAKE_UNIQUE, , , , )
#undef _MAKE_UNIQUE

#else  // not MSVC 11.0 or earlier

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

#endif

// template< class T >
// unique_ptr<T> make_unique( std::size_t size );

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

// template< class T, class... Args >
// /* unspecified */ make_unique( Args&&... args ) = delete;

// MSVC 11.0 doesn't support deleted functions, so the best we can do
// is simply not define the function.
#if !(defined(_MSC_VER) && (_MSC_VER < 1800))

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

#endif

}  // namespace std

#endif  // !COMPILER_SUPPORTS_MAKE_UNIQUE