C++ Arrays and make_unique

Question

As a follow up to this post I wonder how its implementation of make_unique plays with allocating function-temporary buffer arrays such as in the following code.

f()
{
  auto buf = new int[n]; // temporary buffer
  // use buf ...
  delete [] buf;
}

Can this be replaced with some call to make_unique and will the []-version of delete be used then?

Reading the answers: no, there is no simple answer :( – JHBonarius Nov 03 '19 at 13:31 — JHBonarius, Nov 03 '19 at 13:31

score 19 · Accepted Answer · answered Apr 14 '12 at 01:14

Here is another solution (in addition to Mike's):

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

template <class T, class ...Args>
typename std::enable_if
<
    !std::is_array<T>::value,
    std::unique_ptr<T>
>::type
make_unique(Args&& ...args)
{
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

template <class T>
typename std::enable_if
<
    std::is_array<T>::value,
    std::unique_ptr<T>
>::type
make_unique(std::size_t n)
{
    typedef typename std::remove_extent<T>::type RT;
    return std::unique_ptr<T>(new RT[n]);
}

int main()
{
    auto p1 = make_unique<int>(3);
    auto p2 = make_unique<int[]>(3);
}

Notes:

new T[n] should just default construct n T's.

So make_unique(n) should just default construct n T's.

Issues like this contributed to make_unique not being proposed in C++11. Another issue is: Do we handle custom deleters?

These are not unanswerable questions. But they are questions that haven't yet been fully answered.

... but these questions have been (partially) answered in C++14, and make_unique is now [richer](http://en.cppreference.com/w/cpp/memory/unique_ptr/make_unique). — einpoklum, Nov 07 '16 at 15:21

score 4 · Answer 2 · 2012-05-10T21:53:12.467

I got it working with this code:

#include <memory>
#include <utility>

namespace Aux {
    template<typename Ty>
    struct MakeUnique {
        template<typename ...Args>
        static std::unique_ptr<Ty> make(Args &&...args) {
            return std::unique_ptr<Ty>(new Ty(std::forward<Args>(args)...));
        }
    };

    template<typename Ty>
    struct MakeUnique<Ty []> {
        template<typename ...Args>
        static std::unique_ptr<Ty []> make(Args &&...args) {
            return std::unique_ptr<Ty []>(new Ty[sizeof...(args)]{std::forward<Args>(args)...});
        }
    };
}

template<typename Ty, typename ...Args>
std::unique_ptr<Ty> makeUnique(Args &&...args) {
    return Aux::MakeUnique<Ty>::make(std::forward<Args>(args)...);
}

C++ Arrays and make_unique

2 Answers2

Linked