Пишу примитивный никому не нужный контейнер

#include <iostream>
#include <initializer_list>
 
using namespace std;
 
template <typename T>
class array
{
private:
    //Указатель на память в которой хранится массив
    T* ptr;
 
    //Размер массива
    size_t _size;
 
public:
    //Конструктор по умолчанию
    array() : ptr(0), _size(0) {};
 
    //Конструктор копирования
    array(array& arr)
    {
        _size = arr._size;
        ptr = new T[arr._size];
        memcpy(ptr, arr.ptr, arr._size);
    }
 
    //Конструктор, создающий массив заданного размера
    array(size_t size) : _size(size), ptr(new T[size]) {}
 
    //Конструктор, инциализирующий массив
    array(initializer_list<T> values) : _size(values.size()), ptr(new T[values.size()])
    {
        const T* tmp = values.begin();
        for (int i = 0; i < _size; i++)
            ptr[i] = *tmp++;
    }
 
    //Деструктор
    ~array() { delete[] ptr; }
 
    //Перегрузка оператора [] для доступа к элементам массива
    T& operator [] (size_t index) { return ptr[index]; }
 
    //Получение размера массива
    size_t size() { return _size; }
 
    //Изменение размера массива
    void resize(size_t newsize)
    {
        T* tmp = new T[newsize];
        memcpy(tmp, ptr, _size < newsize ? _size : newsize);
        delete[] ptr;
        ptr = tmp;
        _size = newsize;
    }
};

#include "array.h"
 
int main()
{
    array<int> a({ 2, 3, 1 });
    array<int> b(a);
    int x[] = { b[0], b[1], b[2] };
    return 0;
}

namespace my_container
{
    class array { /* ... */ };
}

class Array
{
private:
const size_t min_size(100);
const size_t min_size = 100;
}

struct Array {
    Array() : min_size(42) {}
    
    const int min_size; 
};

struct Array {
    static const int min_size = 42;
};

throw std::out_of_range("Index of array is out of range!");

#include <iostream>
#include <initializer_list>
#include <algorithm>
#include <stdexcept>
 
template <typename T>
class Array
{
private:
    //Минимальный размер выделенной памяти (количество элементов)
    const size_t m_min_size = 100;
 
    //Коэффициент перевыделения памяти
    const double m_k = 1.25;
 
    //Указатель на память в которой хранится массив
    T* m_ptr;
 
    //Размер массива
    size_t m_size;
 
    //Количество элементов массива на которые выделена память
    size_t m_max_size;
 
public:
    //Конструктор по умолчанию
    Array() : m_size(0), m_max_size(m_min_size)  { m_ptr = new T[m_max_size]; }
 
    //Конструктор копирования
    Array(const Array& arr)
    {
        m_size = arr.m_size;
        m_max_size = arr.m_max_size;
        m_ptr = new T[arr.m_max_size];
        std::copy(&arr.m_ptr[0], &arr.m_ptr[arr.m_size], m_ptr);
    }
 
    //Конструктор, создающий массив заданного размера
    Array(size_t size)
    {
        m_max_size = (m_size = size) > m_min_size ? m_size : m_min_size;
        m_ptr = new T[m_max_size];
    }
 
    //Конструктор, инциализирующий массив
    Array(std::initializer_list<T> values)
    {
        m_size = values.size();
        m_max_size = m_size > m_min_size ? m_size : m_min_size;
        m_ptr = new T[m_max_size];
        std::copy(values.begin(), values.end(), m_ptr);
    }
 
    //Деструктор
    ~Array() { delete[] m_ptr; }
 
    //Перегрузка оператора [] для доступа к элементам массива
    T& operator [] (size_t index)
    {
        if (index >= m_size) 
            throw std::out_of_range("Index of array is out of range!");
        else 
            return m_ptr[index];
    }
 
    //Получение размера массива
    size_t size() { return m_size; }
 
    //Изменение размера массива
    void resize(size_t newsize)
    {
        if (newsize > m_max_size)
        {
            m_size = m_max_size;
            T* tmp = new T[m_max_size = newsize * m_k];
            std::copy(&tmp[0], &tmp[m_size], m_ptr);
            delete[] m_ptr;
            m_ptr = tmp;
            m_size = newsize;
        }
        else m_size = newsize;
    }
 
    //Вставка элементов в конец
    void push_back(const T& value)
    {
        if (++m_size > m_max_size) resize(m_size);
        m_ptr[m_size - 1] = value;
    }
};

int main() {
    const Array<int> a{1, 2, 3};
    a.size();
}

Array<int> a(42), b = a;

    Array() : m_size(0), m_max_size(m_min_size)  { m_ptr = new T[m_max_size]; }