DynamicArray.h


#pragma once
#include <assert.h>
#include <cstddef>


/**
 * DynArray - A dynamic array container with manual memory management
 *
 * Example:
 *   DynArray<int> v;
 *   v.PushBack(10);
 *   v.PushBack(20);
 *   for (int elem : v) std::cout << elem << "\n";
 *   DynArray<int> v2;
 *   v2 = v;
 */

template <typename T>
/**
 * This generic class is templated to support any data type T. Internally, it manages a
 * dynamically allocated array to store the elements, which grows in capacity as needed.
*/
class DynArray {
    using SizeType = std::size_t;

    /**
     * A pointer to data of the dynamic array.
     *
     * This pointer is dynamically allocated and managed by the class to store elements
     * of the array.
     *
     * The memory for this pointer is reallocated when the array's capacity grows
     */
    T* Data;

    SizeType CurrentSize;
    SizeType CurrentCapacity;

    /**
     * Doubles the capacity of the dynamic array when it is full and reallocates the "data".
     *
     * If the current capacity is zero, the method initializes the capacity to 1 and allocates memory for the array.
     * Otherwise, the capacity is doubled, and the method allocates new memory for the array.
     *
     */
    void Grow() {
        if (CurrentCapacity == 0)
        {
            CurrentCapacity = 1;
            Data = new T[CurrentCapacity];
        }
        else
        {
            CurrentCapacity*=2;

            T* OldData = Data;
            Data = new T[CurrentCapacity];

            for (SizeType i = 0; i < CurrentSize; ++i)
                Data[i] = OldData[i];

            delete[] OldData;
        }
    }


public:

    DynArray() : Data(nullptr), CurrentSize(0), CurrentCapacity(0) {
    } ;

    ~DynArray() {
        delete[] Data;
    };

    // Copy Constructor
    DynArray(const DynArray& other) :
    Data(nullptr), CurrentSize(0), CurrentCapacity(0)
    {
        if (other.CurrentSize > 0) {
            CurrentCapacity = other.CurrentSize;
            Data = new T[CurrentCapacity];

            for (SizeType i = 0; i < CurrentCapacity; ++i) {
                Data[i] = other.Data[i];
            }

            CurrentSize = other.CurrentSize;
        }
    }

    // Copy Assignment
    DynArray& operator=(const DynArray& other)
    {
        if (this == &other)
            return *this;
        delete[] Data;
        Data = nullptr;
        CurrentSize = other.CurrentSize;
        CurrentCapacity = other.CurrentCapacity;

        Data = new T[CurrentCapacity];

        for (SizeType i = 0; i < CurrentSize; ++i)
        {
            Data[i] = other.Data[i];
        }

        return *this;
    }

    // Move constructor transfers ownership of resources from another DynArray instance.
    DynArray(DynArray&& other) noexcept :
    Data(other.Data), CurrentSize(other.CurrentSize), CurrentCapacity(other.CurrentCapacity)
    {
        other.Data = nullptr;
        other.CurrentSize = 0;
        other.CurrentCapacity = 0;
    }

    // Move Assigment
    DynArray& operator=(DynArray&& other) noexcept
    {
        if (this == &other)
            return *this;

        delete[] Data;

        Data = other.Data;
        CurrentSize = other.CurrentSize;
        CurrentCapacity = other.CurrentCapacity;

        other.Data = nullptr;
        other.CurrentSize = 0;
        other.CurrentCapacity = 0;

        return *this;
    }


    [[nodiscard]] SizeType Size() const { return CurrentSize; };
    [[nodiscard]] SizeType Capacity() const { return CurrentCapacity; };


    void PushBack(const T& value)
    {
        if (CurrentSize >= CurrentCapacity)
            Grow();

        Data[CurrentSize++] = value;
    }

    /**
     * Operator overloading to read and write our data:
     * const DynArray<int> v;
     * v[0] = 5; <- Writing
     * int x = v[0]; <- Reading
     * The non-const function gives a reference allowing to write and read data.
     * The const function gives a const reference allowing only to read data.
     */
    T& operator[](SizeType index)
    {
        assert(index < CurrentSize);
        return Data[index];
    }

    // Provides read-only access to an element at the specified index in the dynamic array.
    const T& operator[](SizeType index) const
    {
        assert(index < CurrentSize);
        return Data[index];
    }

    /** iterator logic **/

    // Returns a pointer to the beginning of the dynamic array.
    T* begin() { return Data; }

    // Returns a pointer to one past the last element in the dynamic array.
    T* end() { return Data + CurrentSize; }

    // This method provides a read-only iterator to the first element of the data.
    const T* begin() const { return Data; }

    // A const pointer to the position one past the last element of the array.
    const T* end() const { return Data + CurrentSize; }
};