Manually resize array in C++ [duplicate]

Essentially the only way is to use a dynamic array (one created using new[]) and to create an entirely new dynamic array and copy (or move) the objects from the old array to the new one.

Something like this:

class Line {

public:
    Line(): index(0), points(nullptr) {} // initialize
    virtual ~Line() { delete[] points; } // Clean up!

    void push(const Point& p)
    {
        // create new array one element larger than before
        auto new_points = new Point[index + 1];

        // copy old elements to new array (if any)
        for(unsigned int p = 0; p < index; ++p)
            new_points[p] = points[p];

        new_points[index] = p; // then add our new Point to the end

        ++index; // increase the recorded number of elements

        delete[] points; // out with the old

        points = new_points; // in with the new


    }

private:
    unsigned int index;  // size of "points" array
    Point* points;

};

But this approach is very inefficient. To do this well is quite complex. The main problems with doing things this way are:

• Exception safety - avoiding a memory leak if an exception is thrown.
• Allocation - avoiding having to reallocate (and re-copy) every single time.
• Move semantics - taking advantage of some objects ability to be moved much more efficiently than they are copied.

A (slightly) better version:

class Line {

public:
    Line(): index(0) {} // initialize
    virtual ~Line() { } // No need to clean up because of `std::unique_ptr`

    void push(const Point& p)
    {
        // create new array one element larger than before
        auto new_points = std::unique_ptr<Point[]>(new Point[index + 1]);    

        // first add our new Point to the end (in case of an exception)
        new_points[index] = p; 

        // then copy/move old elements to new array (if any)
        for(unsigned int p = 0; p < index; ++p)
            new_points[p] = std::move(points[p]); // try to move else copy

        ++index; // increase the recorded number of elements

        std::swap(points, new_points); // swap the pointers
    }

private:
    unsigned int index;  // size of "points" array
    std::unique_ptr<Point[]> points; // Exception safer

};

That takes care of exception safety and (to some degree - but not entirely) move semantics. However it must be pointed out that exception safety is only going to be complete if the elements stored in the array (type Point) are themselves exception safe when being copied or moved.

But this does not deal with efficient allocation. A std::vector will over allocate so it doesn't have to do it with every new element. This code also misses a few other tricks that a std::vector would employ (like allocating uninitialized memory and constructing/destructing the elements manually as and when they are needed/discarded).

You basically have no way but to allocate a new array, copy existing values inside and delete [] the old one. That's why vector is doing the reallocation by a multiplicative factor (say each reallocation doubles the size). This is one of the reasons you want to use the standard library structures instead of reimplementing.

Keep It Simple

In my opinion, in this case, it's better to use a Linked-List of CPoint in CLine:

struct CPoint
{
    int x = 0, y = 0;
    CPoint * m_next = nullptr;
};


class CLine
{
public:
    CLine() {};
    virtual ~CLine()
    {
        // Free Linked-List:
        while (m_points != nullptr) {
            m_current = m_points->m_next;
            delete m_points;
            m_points = m_current;
        }
    };

    // TAKE IN NEW POINT, INCREASE THE ARRAY SIZE AND ADD NEW POINT TO THE END OF THE ARRAY
    void push(const CPoint& p)
    {
        m_current = (((m_points == nullptr) ? (m_points) : (m_current->m_next)) = new CPoint);
        m_current->m_x = p.m_x;
        m_current->m_y = p.m_y;
        m_index++;
    };

private:
    unsigned int m_index = 0;  // size of "points" array
    CPoint * m_points = nullptr, * m_current = nullptr;
};

.

Or, even better with smart pointers:

#include <memory>

struct CPoint
{
    int m_x = 0, m_y = 0;
    std::shared_ptr<CPoint> m_next;
};


class CLine
{
public:
    CLine() {};
    virtual ~CLine() {}

    // TAKE IN NEW POINT, INCREASE THE ARRAY SIZE AND ADD NEW POINT TO THE END OF THE ARRAY
    void push(const CPoint& p)
    {
        m_current = (((m_points == nullptr) ? (m_points) : (m_current->m_next)) = std::make_shared<CPoint>());
        m_current->m_x = p.m_x;
        m_current->m_y = p.m_y;
        m_index++;
    };

private:
    unsigned int m_index = 0;  // size of "points" array
    std::shared_ptr<CPoint> m_points, m_current;
};