template<typename T>
ContiguousContainer<T>::ContiguousContainer()
    : mSize(0), mCapacity(10) {
    // Allocate memory for 10 objects initially
    mData = static_cast<T*>(malloc(mCapacity * sizeof(T)));
    if (!mData) {
        throw std::bad_alloc();
    }
}

template<typename T>
ContiguousContainer<T>::~ContiguousContainer() {
    // Destroy all constructed objects
    for (size_t i = 0; i < mSize; ++i) {
        mData[i].~T();
    }
    // Free the allocated memory
    free(mData);
}

template<typename T>
template<typename... Args>
void ContiguousContainer<T>::pushBack(Args&&... args) {
    if (mSize == mCapacity) {
        // Double the capacity if the container is full
        resize(mCapacity * 2);
    }
    // Use placement new with perfect forwarding to construct the object in place
    new (mData + mSize) T(std::forward<Args>(args)...);
    ++mSize;
}

template<typename T>
void ContiguousContainer<T>::popBack() {
    if (mSize > 0) {
        --mSize;
        // Explicitly call the destructor
        mData[mSize].~T();
    }
}

template<typename T>
T& ContiguousContainer<T>::operator[](size_t index) {
    if (index >= mSize) {
        throw std::out_of_range("Index out of range");
    }
    return mData[index];
}

template<typename T>
size_t ContiguousContainer<T>::getSize() const {
    return mSize;
}

// Function that returns a vector of references to all stored objects
template<typename T>
std::vector<std::reference_wrapper<T>> ContiguousContainer<T>::getAllReferences() {
    std::vector<std::reference_wrapper<T>> references;
    references.reserve(mSize);  // Reserve space to avoid reallocation
    for (size_t i = 0; i < mSize; ++i) {
        references.push_back(std::ref(mData[i]));
    }
    return references;
}

template<typename T>
void ContiguousContainer<T>::resize(size_t new_capacity) {
    // Allocate new memory block with the updated capacity
    T* new_data = static_cast<T*>(malloc(new_capacity * sizeof(T)));
    if (!new_data) {
        throw std::bad_alloc();
    }

    // Move or copy existing objects to the new memory block
    for (size_t i = 0; i < mSize; ++i) {
        new (new_data + i) T(std::move(mData[i])); // Move the objects
        mData[i].~T(); // Call the destructor for the old object
    }

    // Free the old memory block
    free(mData);
    mData = new_data;
    mCapacity = new_capacity;
}