Can't initialize std::unique_ptr

Question

I have written a stack class:

template <class child_t>
class stack {
    const size_t c_init_cap = 12;
    size_t m_size;
    size_t m_capacity;
    std::unique_ptr<child_t[]> m_head;
public:
    /**
     * @brief Default constructor
     */
    stack() : m_size{0}, m_capacity{c_init_cap},
        m_head{std::make_unique<child_t[]>(new child_t[m_capacity])}
    {}
    /**
     * @brief Copy constructor (deleted)
     * @param other Reference to an original object
     */
    stack(const stack &other) = delete;
    /**
     * @brief Move constructor (default)
     * @param other R-value reference to an original object
     */
    stack(stack &&other) = default;
    /**
     * @brief Destructor
     */
    ~stack() {}
    /**
     * @brief Move assigment (default)
     * @param other R-value reference to an original object
     */
    stack& operator =(stack &&other) = default;
    /**
     * @brief Pushes a new value into the stack
     * @param value New value
     */
    void push(child_t value) {
        if (m_size == m_capacity) { increase(); }
        m_head[m_size++] = std::move(value);
    }
    /**
     * @brief Pops a top value from the stack
     */
    void pop() { --m_size; }
    /**
     * @brief Returns a reference to a top value of the stack
     * @return Top value
     */
    child_t &top() { return m_head[m_size - 1]; }
    /**
     * @brief Returns a reference to a top value of the stack
     * @return Top value
     */
    const child_t &top() const { return m_head[m_size - 1]; }
    /**
     * @brief Returns a stack size
     * @return Stack size
     */
    size_t size() const { return m_size; }
    /**
     * @brief Checks if the stack is empty
     * @return Check result
     */
    bool empty() const { return m_size == 0; }
private:
    /**
     * @brief Increases the pre-allocated capacity of the buffer doubly
     */
    void increase() {
        m_capacity <<= 1;
        auto tmp = new child_t[m_capacity];
        std::copy(m_head, m_head + m_size - 1, tmp);
        m_head.reset(tmp);
    }
};

But I'm getting an error on build:

/home/Task_3_3/task_3_3/stack.h:20: error: no matching function for call to ‘make_unique<int []>(int*)’
         m_head{std::make_unique<child_t[]>(new child_t[m_capacity])}
                ~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~

What does it mean? And how can I fix?
P.S. I'm learning C++ only, so I am a noobie still...

The idea of `make_unique` is that you don't have to call `new` which makes it exception-safe. Try `m_head{std::make_unique(m_capacity)}`. — Henri Menke, Mar 14 '18 at 01:15
You would be soooo much better off using std::vector. Life always goes better with std::vector — pm100, Mar 14 '18 at 01:17
@pm100 Unfortunately, my task doesn't allow to use STL containers. — Denis Sologub, Mar 14 '18 at 01:19
// This comment contains a complaint about comments saying what code clearly does on the next line. `Please don't write comments that just repeat what the code on the next line does, but does it over 4 lines` — Yakk - Adam Nevraumont, Mar 14 '18 at 18:28

score 6 · Answer 1 · answered Mar 14 '18 at 01:16

6

The correct use of std::make_unique with an array type is to provide the size of the array as argument.

The correct way of initializing m_head would then be m_head{std::make_unique<child_t[]>(m_capacity)}.

answered Mar 14 '18 at 01:16

François Andrieux

28,148
6
56
87

Thank you very much for explanation! – Denis Sologub Mar 14 '18 at 01:19

score 3 · Answer 2 · answered Mar 14 '18 at 01:30

3

Probably the most important reason to use make_unique is to avoid using new operator. You can read this quesiton for more information: Exception safety and make_unique.

So in your case:

std::make_unique<child_t[]>(m_capacity);

answered Mar 14 '18 at 01:30

Yola

18,496
11
65
106

Can't initialize std::unique_ptr

2 Answers2