DynamicArray.cpp

#include <iostream>
using namespace std;

// Implementing Dynamic Array with Static Array
template <typename T>
struct DynamicArray
{
    int capacity = 1; //reserved space
    int size = 0; //used space
    T *data = new T[capacity];

    // Destructor to release memory when object is destroyed
    ~DynamicArray() {
        delete[] data;
    }
};
template <typename T>
void append(DynamicArray<T>& arr, T ele){
    if (arr.size >= arr.capacity)
    {
        increase_capacity(arr);
    }
    arr.size++;
    arr.data[arr.size-1] = ele;
}
template <typename T>
void insert(DynamicArray<T>& arr,int pos ,T ele){
    if (pos > arr.size)
    {
        cout<<"Index out of bounds!";
        return;
    }
    if (arr.size >= arr.capacity)
    {
        increase_capacity(arr);
    }
    for (size_t i = arr.size; i > pos ; i--)
    {
        arr.data[i] = arr.data[i-1];
    }
    arr.data[pos] = ele;
    arr.size++;
}
template <typename T>
void remove_index(DynamicArray<T>& arr,int pos){
    if (pos > arr.size)
    {
        cout<<"Index out of bounds!";
        return;
    }
    if (arr.size <= (arr.capacity)/2)
    {
        decrease_capacity(arr);
    }
    for (size_t i = pos; i < arr.size ; i++)
    {
        arr.data[i] = arr.data[i+1];
    }
    arr.size--;
}
template <typename T>
void remove_ele(DynamicArray<T>& arr,T ele){
    size_t ele_index = indexOf(arr,ele);
    if (ele_index == -1)
    {
        cout<<"Element not Found!"<<endl;
    }
    else{
        remove_index(arr,ele_index);
    }
}
template <typename T>
void increase_capacity(DynamicArray<T>& arr){
    T *new_data = new T[2 * arr.capacity];
    for (size_t i = 0; i < arr.size; i++)
    {
        new_data[i] = arr.data[i];
    }
    delete[] arr.data;
    arr.data = new_data;
    arr.capacity *= 2;
}
template <typename T>
void decrease_capacity(DynamicArray<T>& arr){
    T *new_data = new T[(arr.capacity)/2];
    for (size_t i = 0; i < arr.size; i++)
    {
        new_data[i] = arr.data[i];
    }
    delete[] arr.data;
    arr.data = new_data;
    arr.capacity /= 2;
}
template <typename T>
size_t indexOf(const DynamicArray<T>& arr, T ele){
    for (size_t i = 0; i < arr.size; i++)
    {
        if (arr.data[i] == ele)
        {
            return i;
        }
    }
    return -1;
}
template <typename T>
bool contains(const DynamicArray<T>& arr, T ele){
    for (size_t i = 0; i < arr.size; i++)
    {
        if (arr.data[i] == ele)
        {
            return true;
        }
    }
    return false;
}
template <typename T>
void clear(DynamicArray<T>& arr){
    delete[] arr.data;
    arr.size = 0;
    arr.capacity = 1; // Reset to initial capacity
    arr.data = new T[arr.capacity]; // Allocate fresh memory
}
template <typename T>
bool isEmpty(const DynamicArray<T>& arr){
    return arr.size == 0;
}
int main(int argc, char const *argv[])
{
    DynamicArray<int> arr;
    append(arr,9);
    append(arr,8);
    append(arr,7);
    append(arr,1);
    append(arr,2);
    insert(arr,2,5);
    insert(arr,2,3);
    insert(arr,0,0);
    insert(arr,1,6);
    remove_index(arr,2);
    // remove_ele(arr,9);
    remove_ele(arr,8);
    
    if (contains(arr,8))
    {
        cout<<"true";
    }
    else{
        cout<<"false";
    }
    
    cout<< arr.capacity << "\n";

    for (size_t i = 0; i < arr.size; i++)
    {
        cout<<arr.data[i]<<", ";
    }
    
    return 0;
}