Overload(const size_t *value)
 {
  set_capasity(1);
 }

что за ловушки

Это изначальный размер массива потом он расширяется

правда, поведение int64_t x = elem; не определено, если значение elem больше, чем максимально возможное для int64_t

Достаточно определено же

правда, поведение int64_t x = elem; не определено, если значение elem больше, чем максимально возможное для int64_t

и что происходит?

Только ручками и манипуляциями с битами?

если в десятичном виде, то разделить на части размера 10^N и выводить (как костыль)

#include <iostream>
/*
ДОМАШНЕЕ ЗАДАНИЕ
Задание 1: Реализуйте следующие методы для IntArray
- перегрузите оператор[](для доступа к элементам массива)
- перегрузите оператор + для объединения двух массивов(возвращает новый
IntArray, который содержит элементы первого и второго массива)
- перегрузите оператор ввода и вывода для типа IntArray
*/

class Overload
{
public:
Overload() = default;
Overload(const size_t *value)
{
 set_capasity(1);
}

void set_capasity(const size_t& value)
{
 size_t* temp_arr = new size_t[value];
 for (int i = 0; i < m_lenght; i++)
 {
  temp_arr[i] = m_arr[i];
 }
 delete[]m_arr;
 m_arr = temp_arr;
 m_capasity = value;
}

void new_element(const size_t& element)
{
 if (m_lenght == m_capasity)
 {
  set_capasity(m_capasity + 2);
 }
 m_arr[m_lenght] = element;
 m_lenght++;
}

size_t& operator[](size_t value)
{
 return m_arr[value];
}

Overload operator + (const Overload& right) const
{
 Overload temp_arr;
 for (int i = 0; i < m_lenght; i++)
 {
  temp_arr.new_element(m_arr[i]);
 }

 for (int i = m_lenght; i < right.m_lenght; i++)
 {
  temp_arr.new_element(right.m_arr[i]);
 }

 return temp_arr;
}

~Overload()
{
 delete[]m_arr;
}
private:
size_t m_lenght = 0;
size_t m_capasity = 0;
size_t* m_arr = nullptr;
};

void main()
{
Overload arr;
arr.new_element(15);
arr.new_element(5);
arr.new_element(1);
arr.new_element(6);
arr.new_element(9);
arr.new_element(7);
arr.new_element(8);
arr.new_element(9);
arr.new_element(1);

std::cout << arr[5];
std::cout << '\n';
Overload arr1;
arr1.new_element(35);
arr1.new_element(61);
arr1.new_element(11);
arr1.new_element(67);
arr1.new_element(99);
arr1.new_element(73);
arr1.new_element(81);
arr1.new_element(92);
arr1.new_element(18);

std::cout << arr1[5];

Overload arr2 = arr + (arr1);
}

Можно за <=128 операций же