Оптимизация памяти при перегрузке операторов и структурах шаблонов

Задание:

В этой задаче вам нужно написать структуру, которая будет работать как обычный массив в C и как список в Python. А именно, напишите структуру

template<typename T>
struct FlexArray;

Те. это шаблонная структура. Это массив элементов типа T фиксированной длины, длина передается в конструктор. По умолчанию следует считать, что длина равна 0. (Это не обязывает вас использовать при реализации только классические массивы)

Доступ к элементам осуществляется через метод at(unsigned int index) — возвращает индексный элемент массива. Напишите этот метод правильно как для неконстантных, так и для константных структур. А именно, вызов at(i) для константных структур не должен допускать изменения содержимого массива и, более того, не может появляться слева от знака =.

Size(), который возвращает текущий размер массива.

Теперь самое интересное.

Напишите operator+ из двух FlexArrays и operator+=, где добавление FlexArray считается конкатенацией их элементов. Те. {1, 3, 5} + {2, 4} = {1, 3, 5, 2, 4}.

Вы можете добавить два разных FlexArrays, только если их аргументы шаблона совпадают.

operator += должен фактически добавить новый массив к текущему FlexArray.

Также напишите operator* и operator*= от FlexArray и числа k > 0, где умножение на число k — это объединение самого себя k раз. Те. {1, 2} * 3 = {1, 2, 1, 2, 1, 2}. Мы можем предположить, что k — это unsigned long

Умножать нужно как слева направо, так и справа налево. Те. Возможны только 3 варианта FlexArray *= k, FlexArray * k, k * FlexArray

int main() {
 FlexArray<int> flex(3);
 flex.at(0) = 1;
 flex.at(1) = 2;
 flex.at(2) = 3;
 std::cout << flex.Size(); // 3

 auto prod = flex * 2;

 for (int i = 0; i < prod.Size(); ++i) {
  std::cout << prod.at(i) << " ";
 }
 std::cout << "\n";
 // Should output 1 2 3 1 2 3

 FlexArray<int> last(2);
 last.at(0) = 4;
 last.at(1) = 5;
 flex += last;

 for (int i = 0; i < flex.Size(); ++i) {
  std::cout << flex.at(i) << " ";
 }
 std::cout << "\n";
 // Should output 1 2 3 4 5

}

Итак, реализация этих методов зависит от вас; типы возвращаемых значений здесь специально не прописаны:

FlexArray<T>::FlexArray();
FlexArray<T>::FlexArray(size_t);
FlexArray<T>::at(size_t);
FlexArray<T>::Size();
FlexArray<T>::operator += (const FlexArray&);
FlexArray<T>::operator *= (size_t);
operator+(const FlexArray<T>&, const FlexArray<T>&);
operator*(const FlexArray<T>&, size_t);
operator*(size_t, const FlexArray<T>&);

Отправьте в систему только код структуры + возможно необходимо # include

Это мое решение:

template<typename T>
struct FlexArray {
    std::vector<T> vec;
    FlexArray();
    FlexArray(size_t n);
    T& at(size_t index);
    const T& at(size_t index) const;
    size_t Size() const;
    FlexArray& operator += (const FlexArray& another);
    FlexArray& operator *= (size_t k);
};

template<typename T>
FlexArray<T>::FlexArray() : vec(0){}

template<typename T>
FlexArray<T>::FlexArray(size_t n) : vec(n) {}

template<typename T>
T& FlexArray<T>::at(size_t index) {
    return vec[index];
}

template<class T>
const T& FlexArray<T>::at(size_t index) const {
    return vec[index];
}

template<typename T>
size_t FlexArray<T>::Size() const{
    return vec.size();
}

template<typename T>
FlexArray<T>& FlexArray<T>::operator += (const FlexArray& another) {
    for (size_t i = 0; i < another.Size(); i++) {
        vec.push_back(another.at(i));
    }
    return *this;
}

template<typename T>
FlexArray<T>& FlexArray<T>::operator *= (size_t k) {
    auto copy = *this;
    for (size_t i = 1; i < k; i++) {
        *this += copy;
    }
    return *this;
}

template<typename T>
FlexArray<T> operator+(const FlexArray<T>& left, const FlexArray<T>& right) {
    auto copy = left;
    copy += right;
    return copy;
}

template<typename T>
FlexArray<T> operator*(const FlexArray<T>& arr, size_t k) {
    auto copy = arr;
    copy *= k;
    return copy;
}

template<typename T>
FlexArray<T> operator*(size_t k, const FlexArray<T>& arr) {
    return arr * k;
}

Проблема в том, что он не проходит тест памяти (ограничение 64 МБ). Мой код выдает 100мс/86,77Мб.

В системе тестирования используется G++17 7.3.

Как я могу это оптимизировать? (задание взято из онлайн-курса и я уверен, что код можно как-то оптимизировать не очень сложно, или я где-то ошибся)