Шаблоны и обработка исключений

#include <iostream>
 
template<typename T>
class Array
{
private:
    T* _data;
    int _length;
    int _capacity;
 
    void EnsureCapacity(int capacity, int insertIndex = -1)
    {
        if (_capacity < capacity)
        {
            while (_capacity < capacity)
            {
                _capacity *= 2;
            }
 
            T *oldData = _data;
            T *_data = new T[_capacity];
            if (insertIndex >= 0)
            {
                CheckIndex(insertIndex);
 
                memcpy(_data, oldData, sizeof(T) * insertIndex);
                memcpy(_data + insertIndex + 1, oldData + insertIndex, sizeof(T) * (_length - insertIndex));
            }
            else
            {
                memcpy(_data, oldData, sizeof(T) * _length);
            }
 
 
            delete(oldData);
        }
        else if (insertIndex >= 0)
        {
            CheckIndex(insertIndex);
 
            memcpy(_data, _data, sizeof(T) * insertIndex);
            memcpy(_data + insertIndex + 1, _data + insertIndex, sizeof(T) * (_length - insertIndex));
        }
    }
 
    void CheckIndex(int index)
    {
        if (index < 0 || index >= _length)
        {
            throw "Index was out of range!";
        }
    }
 
public:
    Array()
    {
        _capacity = 32; // начальный буффер
        _length = 0;
        _data = new T[_capacity];
    }
 
    virtual ~Array()
    {
        delete(_data);
    }
 
    int Add(T item)
    {
        EnsureCapacity(_length + 1);
        _data[_length] = item;
        _length++;
        return _length - 1;
    }
 
    int Insert(int index, T item)
    {
        EnsureCapacity(_length + 1, index);
        _length++;
        _data[index] = item;
        return index;
    }
 
    T Get(int index)
    {
        CheckIndex(index);
 
        return _data[index];
    }
 
    int FindNext(int index, T item)
    {
        for (int i = index; i < _length; ++i)
        {
            if (_data[i] == item)
            {
                return i;
            }
        }
        return -1;
    }
 
    int FindFirst(T item)
    {
        return FindNext(0, item);
    }
 
    void RemoveRange(int start, int count)
    {
        CheckIndex(start);
        CheckIndex(start + count);
        memcpy(_data + start, _data + start + count, sizeof(T) * (_length - start - count));
        _length -= count;
    }
 
    void RemoveAt(int index)
    {
        RemoveRange(index, 1);
    }
 
    void RemoveAll(T item)
    {
        int count = 0;
        for (int i = 0; i < _length; ++i)
        {
            if (_data[i] == item)
            {
                count++;
            }
            else if (count > 0)
            {
                _data[i - count] = _data[i];
            }
        }
        _length -= count;
    }
 
    void RemoveAllValuesInRange(T itemFrom, T itemTo)
    {
        T from = itemFrom < itemTo ? itemFrom : itemTo;
        T to = itemFrom > itemTo ? itemFrom : itemTo;
 
        int count = 0;
        for (int i = 0; i < _length; ++i)
        {
            if (_data[i] >= from && _data[i] <= to)
            {
                count++;
            }
            else if (count > 0)
            {
                _data[i - count] = _data[i];
            }
        }
        _length -= count;
    }
 
    T Max()
    {
        if (_length <= 0)
        {
            throw "Array is empty!";
        }
        T max = _data[0];
        for (int i = 1; i < _length; ++i)
        {
            if (max < _data[i])
            {
                max = _data[i];
            }
        }
 
        return max;
    }
 
    T Min()
    {
        if (_length <= 0)
        {
            throw "Array is empty!";
        }
        T min = _data[0];
        for (int i = 1; i < _length; ++i)
        {
            if (min > _data[i])
            {
                min = _data[i];
            }
        }
 
        return min;
    }
 
 
    int GetCount()
    {
        return _length;
    }
 
    void DebugPrintContent(const char* msg)
    {
        std::cout << msg;
        for (int i = 0; i < _length; ++i)
        {
            std::cout << _data[i];
            if (i < _length - 1)
            {
                std::cout << ", ";
            }
        }
        std::cout << std::endl;
    }
};
 
int main() {
    Array<int> a;
    a.Add(1);
    a.Add(2);
    a.Add(5);
    a.Add(3);
 
    a.DebugPrintContent("Array a: ");
    a.Insert(2 , 10);
    a.Insert(0 , 10);
    a.DebugPrintContent("Array a after insert: ");
 
    a.RemoveAll(10);
    a.DebugPrintContent("Array a after removeAll: ");
 
    a.RemoveRange(1,2);
    a.DebugPrintContent("Array a after removeRange: ");
 
    try
    {
        a.RemoveRange(3,1);
        a.DebugPrintContent("This should never print: ");
    }
    catch (const char* err)
    {
        std::cout << "Exception thrown: " << err << std::endl;
    }
 
    Array<float>* b = new Array<float>();
    b->Add(1.0f);
    b->Add(2.5f);
    b->Add(5.3f);
    b->Add(3.0f);
 
    b->DebugPrintContent("Array b: ");
 
    int foundIndex = b->FindFirst(2.5f);
    std::cout << "Element 2.5 position ";
    if (foundIndex < 0)
    {
        std::cout << "not found" << std::endl;
    }
    else
    {
        std::cout << foundIndex << std::endl;
    }
 
    foundIndex = b->FindNext(foundIndex + 1, 2.5f);
    std::cout << "Next element 2.5 position ";
    if (foundIndex < 0)
    {
        std::cout << "not found" << std::endl;
    }
    else
    {
        std::cout << foundIndex << std::endl;
    }
 
    b->Add(2.5f);
    b->DebugPrintContent("Add one more to array b: ");
 
    foundIndex = b->FindNext(foundIndex + 1, 2.5f);
    std::cout << "Next element 2.5 position ";
    if (foundIndex < 0)
    {
        std::cout << "not found" << std::endl;
    }
    else
    {
        std::cout << foundIndex << std::endl;
    }
 
    std::cout << "Array b Max: " << b->Max() << ", Min: " << b->Min() << std::endl;
 
    b->RemoveAllValuesInRange(2, 4);
    b->DebugPrintContent("Array b after remove values from 2 to 4: ");
 
    Array<char> c;
 
    c.DebugPrintContent("Empty array c: ");
 
    try
    {
        char max = c.Max();
        a.DebugPrintContent("This should never print: ");
    }
    catch (const char* err)
    {
        std::cout << "Exception thrown: " << err << std::endl;
    }
 
    c.Add('a');
    c.Add('s');
    c.Add('D');
    c.Add('f');
 
    c.DebugPrintContent("Array c: ");
 
    std::cout << "Array c Max: " << c.Max() << ", Min: " << c.Min() << std::endl;
 
    try
    {
        c.Get(10);
        a.DebugPrintContent("This should never print: ");
    }
    catch (const char* err)
    {
        std::cout << "Exception thrown: " << err << std::endl;
    }
 
    std::cout << "Array c element 2: " << c.Get(2) << std::endl;
 
    c.RemoveAllValuesInRange('A', 'Z');
    c.DebugPrintContent("Array c removed all uppercase: ");
 
    return 0;
}