#include "CDynamicArray.h"
#include <iostream>

#define cout std::cout

int main() {
    CDynamicArray1D<int> array1(5);
    for (int i = 0; i < 10; i++) {
        array1.PushBack(i);
        cout << "int value: " << array1[i] << ", capacity: " << array1.GetCapacity();
    }
}

Ausgabe:
int value: -842150451, capacity: 5
int value: -842150451, capacity: 5
int value: -842150451, capacity: 5
int value: -842150451, capacity: 5
int value: -842150451, capacity: 5
int value: 5, capacity: 5
Assertion failed: _index < m_elementCount, file C:UsersthomasourcereposProject4CDynamicArray.h, line 80

1. Why are there negative numbers? It should be 0, 1, 2, 3, …

2. Why the assertion? The index should be smaller than the ElementCount.

#pragma once
#include <assert.h>

template<typename T>
class CDynamicArray1D
{
public:
    CDynamicArray1D(size_t _capacity);
    CDynamicArray1D();      //initialized with 10 capacity
    ~CDynamicArray1D();     //In case pointer to elements that were created with "new" are in this array, they do not get deleted. Please delete them yourself future me
    CDynamicArray1D(const CDynamicArray1D<T>& r_DynamicArrayToCopy);
    CDynamicArray1D<T>& operator = (const CDynamicArray1D<T>&);

    T operator [] (size_t index);

    void PushBack(T _element);  //if (m_elementCount = m_capacity) SetNewCapacity( (m_capacity * 2) +1 );
    T   PopBack();              //if (m_elementCount < m_capacity * 0.3f) SetNewCapacity( m_capacity * 0.5f );

    int GetCapacity();
    int GetElementCount();

    void CombineWithOtherArray(CDynamicArray1D<T>& _otherArray); //other array is put at the end of this array. Other Array is not being deleted. Capacities are combined. Other array has to be the same typename Variable.

    T AddAllTogether();       //T must be compatible with:  +
    float GetAvarage();       //T must be compatible with:  / and + 
    T GetMax();               //T must be compatible with:  < and >
    T GetMin();               //T must be compatible with:  < and >
     

private:
    void SetNewCapacity(size_t _capacity);
    size_t  m_elementCount;
    size_t  m_capacity;
    T*      mp_data;
};

template<typename T>
inline CDynamicArray1D<T>::CDynamicArray1D(size_t _capacity)
    : m_capacity(_capacity)
    , m_elementCount(0)
{
    mp_data = new T[m_capacity];
}

template<typename T>
inline CDynamicArray1D<T>::CDynamicArray1D()
    : m_capacity(10)
    , m_elementCount(0)
{
    mp_data = new T[m_capacity];
}

template<typename T>
inline CDynamicArray1D<T>::~CDynamicArray1D() 
{
    delete[] mp_data;
}

template<typename T>
inline CDynamicArray1D<T>::CDynamicArray1D(const CDynamicArray1D<T>& r_DynamicArrayToCopy)
    : m_capacity(r_DynamicArrayToCopy.m_capacity)            //Note to self: Zugriffberechtigung passt? Kommt mal kein Fehler in der Fehlerliste
    , m_elementCount(r_DynamicArrayToCopy.m_elementCount)
{
    mp_data = new T[m_capacity];

    for (size_t i = 0; i < this->m_elementCount; i++) {
        this->mp_data[i] = r_DynamicArrayToCopy.mp_data[i];
    }
}

template<typename T>
inline CDynamicArray1D<T>& CDynamicArray1D<T>::operator = (const CDynamicArray1D<T>&)
{
    return CDynamicArray1D();
}

template<typename T>
inline T CDynamicArray1D<T>::operator[](size_t _index)
{
    assert(_index < m_elementCount);
    return mp_data[_index];
}

template<typename T>
inline void CDynamicArray1D<T>::PushBack(T _element)
{
    if (m_elementCount = m_capacity) {
        SetNewCapacity((m_capacity * 2) + 1);
    }
    mp_data[m_elementCount] = _element;
    m_elementCount++;
}

template<typename T>
inline T CDynamicArray1D<T>::PopBack()
{
    if (m_elementCount < m_capacity * 0.5f) {
        SetNewCapacity(m_capacity * 0.6f);
    }
    m_elementCount--;
    return mp_data[m_elementCount];
}

template<typename T>
inline int CDynamicArray1D<T>::GetCapacity()
{
    return m_capacity;
}

template<typename T>
inline int CDynamicArray1D<T>::GetElementCount()
{
    return m_elementCount;
}

template<typename T>
inline void CDynamicArray1D<T>::CombineWithOtherArray(CDynamicArray1D<T>& _otherArray)
{
    SetNewCapacity(this->m_capacity + _otherArray.m_capacity);
    
    for (size_t i = 0; i < _otherArray.m_elementCount; i++) {
        PushBack(_otherArray.mp_data[i]);
    }
}

template<typename T>
inline T CDynamicArray1D<T>::AddAllTogether()
{
    T all_together = 0;
    for (size_t i = 0; i < m_elementCount; i++) {
        all_together = all_together + mp_data[i];
    }
    return all_together;
}

template<typename T>
inline float CDynamicArray1D<T>::GetAvarage()
{
    float avarage = AddAllTogether()/m_elementCount; //note to me: int, float und T in einer Gleichung, muss hier irgendwas gecastet werden, ne wa
    return avarage;
}

template<typename T>
inline T CDynamicArray1D<T>::GetMax()
{
    T max = mp_data[0];

    for (int i = 1; i < m_elementCount; i++) {
        if (mp_data[i] > max) {
            max = mp_data[i];
        }
    }
    return max;
}

template<typename T>
inline T CDynamicArray1D<T>::GetMin()
{
    T min = mp_data[0];

    for (int i = 1; i < m_elementCount; i++) {
        if (mp_data[i] < min) {
            min = mp_data[i];
        }
    }
    return min;
}

template<typename T>
inline void CDynamicArray1D<T>::SetNewCapacity(size_t _capacity)
{
    assert(m_elementCount <= _capacity);
    T* new_data = new T[_capacity];
    for (size_t i = 0; i < this->m_elementCount; i++) {
        new_data[i] = this->mp_data[i];
    }

    delete[] this->mp_data;

    mp_data = new_data;
}

Please help me.<3<3