Dynamic Array Code Implementation

#include <iostream>
#include <stdexcept>
#include <vector>

template<typename E>
class MyArrayList {
private:
    // The underlying array that actually stores the data
    E* data;
    // Record the current number of elements
    int size;
    // Default initial capacity
    static const int INIT_CAP = 1;

public:
    MyArrayList() {
        this->data = new E[INIT_CAP];
        this->size = 0;
    }

    MyArrayList(int initCapacity) {
        this->data = new E[initCapacity];
        this->size = 0;
    }

    // Add
    void addLast(E e) {
        int cap = sizeof(data) / sizeof(data[0]);
        // Check if the capacity of the data array is enough
        if (size == cap) {
            resize(2 * cap);
        }
        // Insert the element at the end
        data[size] = e;
        size++;
    }

    void add(int index, E e) {
        // Check if the index is out of bounds
        checkPositionIndex(index);

        int cap = sizeof(data) / sizeof(data[0]);
        // Check if the capacity of the data array is enough
        if (size == cap) {
            resize(2 * cap);
        }

        // Shift data from data[index..] to data[index+1..]
        // Make room for the new element
        for (int i = size - 1; i >= index; i--) {
            data[i + 1] = data[i];
        }

        // Insert the new element
        data[index] = e;

        size++;
    }

    void addFirst(E e) {
        add(0, e);
    }

    // Remove
    E removeLast() {
        if (size == 0) {
            throw std::out_of_range("NoSuchElementException");
        }
        int cap = sizeof(data) / sizeof(data[0]);
        // Can shrink capacity to save space
        if (size == cap / 4) {
            resize(cap / 2);
        }

        E deletedVal = data[size - 1];
        // Remove the last element
        // Must set the last element to null to prevent memory leak
        data[size - 1] = NULL;
        size--;

        return deletedVal;
    }

    E remove(int index) {
        // Check if the index is out of bounds
        checkElementIndex(index);

        int cap = sizeof(data) / sizeof(data[0]);
        // Can shrink capacity to save space
        if (size == cap / 4) {
            resize(cap / 2);
        }

        E deletedVal = data[index];

        // Shift data from data[index+1..] to data[index..]
        for (int i = index + 1; i < size; i++) {
            data[i - 1] = data[i];
        }

        data[size - 1] = NULL;
        size--;

        return deletedVal;
    }

    E removeFirst() {
        return remove(0);
    }

    // Get
    E get(int index) {
        // Check if the index is out of bounds
        checkElementIndex(index);

        return data[index];
    }

    // Set
    E set(int index, E element) {
        // Check if the index is out of bounds
        checkElementIndex(index);
        // Modify data
        E oldVal = data[index];
        data[index] = element;
        return oldVal;
    }

    // Utility methods
    int getSize() {
        return size;
    }

    bool isEmpty() {
        return size == 0;
    }

    // Resize the data array to newCap
    void resize(int newCap) {
        E* temp = new E[newCap];

        for (int i = 0; i < size; i++) {
            temp[i] = data[i];
        }

        // Release the memory of the original array
        delete[] data;

        data = temp;
    }

    bool isElementIndex(int index) {
        return index >= 0 && index < size;
    }

    bool isPositionIndex(int index) {
        return index >= 0 && index <= size;
    }

    // Check if an element can exist at the index position
    void checkElementIndex(int index) {
        if (!isElementIndex(index)) {
            throw std::out_of_range("Index out of bounds");
        }
    }

    // Check if an element can be added at the index position
    void checkPositionIndex(int index) {
        if (!isPositionIndex(index)) {
            throw std::out_of_range("Index out of bounds");
        }
    }

    void display() {
        std::cout << "size = " << size << " cap = " << sizeof(data) / sizeof(data[0]) << std::endl;
        for (int i = 0; i < size; i++) {
            std::cout << data[i] << " ";
        }
        std::cout << std::endl;
    }

    ~MyArrayList() {
        delete[] data;
    }
};


int main() {
    // Set initial capacity to 3
    MyArrayList<int> arr(3);

    // Add 5 elements
    for (int i = 1; i <= 5; i++) {
        arr.addLast(i);
    }

    arr.remove(3);
    arr.add(1, 9);
    arr.addFirst(100);
    int val = arr.removeLast();

    // 100 1 9 2 3
    for (int i = 0; i < arr.getSize(); i++) {
        std::cout << arr.get(i) << std::endl;
    }

    return 0;
}