Перенагрузка масивов

#include<iostream>
#include<Windows.h>
#include<stack>
using namespace std;
#include <iostream>
#include <string.h>
#include <time.h>
using namespace std;
 
class Queue
{
 // Очередь
 int * Wait;
 // Максимальный размер очереди
 int maxturn;
 // Текущий размер очереди
 int timeturn;
 
public:
 // Конструктор
 Queue(int m);
 
 //Деструктор
 ~Queue();
 
 // Добавление элемента
 void Add(int c); 
 
 // Извлечение элемента
 int Extract();        
 
 // Очистка очереди
 void Clear();    
 
 // Проверка существования элементов в очереди
 bool IsEmpty();    
 
 // Проверка на переполнение очереди
 bool IsFull();     
 
 // Количество элементов в очереди
 int GetCount();   
 
 //демонстрация очереди
 void Show();
};
 
void Queue::Show(){
 cout<<"\n-------------------------------------\n";
 //демонстрация очереди
 for(int i=0;i<timeturn;i++){
 cout<<Wait[i]<<" ";
 }
 cout<<"\n-------------------------------------\n";
}
 
Queue::~Queue()
{
 //удаление очереди
 delete[]Wait;
}
 
Queue::Queue(int m)
{
 //получаем размер
 maxturn=m;
 //создаем очередь
 Wait=new int[timeturn];
 // Изначально очередь пуста
 timeturn = 0;
}
 
void Queue::Clear()
{
 // Эффективная "очистка" очереди 
 timeturn = 0;
}
 
bool Queue::IsEmpty()
{
 // Пуст?
 return timeturn == 0;
}
 
bool Queue::IsFull()
{
 // Полон?
 return timeturn == maxturn;
}
 
int Queue::GetCount()
{
 // Количество присутствующих в стеке элементов
 return timeturn;
}
 
void Queue::Add(int c)
{
    
 // Если в очереди есть, то увеличиваем количество
 // значений и вставляем новый элемент
 if(!IsFull())
 Wait[timeturn++] = c;
 
}
 
int Queue::Extract()
{
    cout<<"Видалено елемент"<<endl;
 // Если в очереди есть элементы, то возвращаем тот, 
 // который вошел первым и сдвигаем очередь 
 if(!IsEmpty()){
 //запомнить первый
 int temp=Wait[0];
 
 //сдвинуть все элементы
 for(int i=1;i<timeturn;i++)
 Wait[i-1]=Wait[i];
 
 //уменьшить количество
 timeturn--;
 
 //вернуть первый(нулевой)
 return temp;
 }
 
 else // Если в стеке элементов нет
     
 return -1;
}
 
void main()
{
  SetConsoleCP(1251);
 SetConsoleOutputCP(1251);
 //создание очереди
 Queue QU(25);
 
 //заполнение части элементов
 for(int i=0;i<5;i++){
 QU.Add(rand()%50);
 }
 //показ очереди
 QU.Show();
 
 //извлечение элемента
 QU.Extract();
 
 //показ очереди
 QU.Show();
 QU.Add(5);
 cout<<"Новий елемент в черзi"<<endl;
  QU.Show();
 system("pause");
}

void operator + (int element)
{
   this->Add(element);
}

QU + 10;

bool operator () (void)
{
   return this->IsEmpty();
}

#include <iostream>
using namespace std;
 
class Safe
{
    int size;     //Размер массива
    int *arr;   //Указатель для хранения массива
    int how_add; //Сколько было добавлено памяти
public:
    Safe (int SIZE); //Конструктор с параметром
    Safe (const Safe &object); //Конструктор копий
    ~Safe ();        //Деструктор
    void Set_to (); //Дополнение массива значениями
    int View (char flag[8]);  //Получение информации с private переменных
    int &operator[] (int i); //Перегрузка оператора индексирования + контроль границ
    friend ostream &operator<< (ostream &stream, Safe &object);  //Вывод всего массива
    friend istream &operator>> (istream &stream, Safe &object); //Заполнение массива с начала
    friend Safe &operator+ (Safe &object, int ADD);  //Добавление размера
    friend Safe &operator- (Safe &object, int ROB); //Уменьшение размера
};
 
Safe::Safe (int SIZE) //Конструктор с параметром
{
    size = SIZE;
    arr = new int[size];
    cout << '\a';
}
Safe::Safe (const Safe &object) //Конструктор копий
{
    size = object.size;
    arr = new int[size];
    for (int i = 0; i < object.size; i++)
        arr[i] = object.arr[i];
    how_add = object.how_add;
}
Safe::~Safe () //Деструктор
{
    delete[] arr;    cout << '\a' << '\a';
}
 
void Safe::Set_to () //Дополнение массива значениями
{
    for (int i = size - how_add; i < size; i++)
        cin >> arr[i];
}
int  Safe::View (char flag[8]) //Получение информации с private переменных
{
    if (flag == "size" )        return size;        
    else if (flag == "how_add") return how_add;
    else return 0;
}
 
int &Safe::operator[] (int i) //Перегрузка оператора индексирования + контроль границ
{
    if (i < 0 || i > size-1)
        cout << endl << "Warning! Exceeded! " << endl;
    else return arr[i];
}
ostream &operator<< (ostream &stream, Safe &object) //Вывод всего массива
{
    for (int i = 0; i < object.size; i++)
        stream << object[i] << " ";
    return stream;
}
istream &operator>> (istream &stream, Safe &object) //Заполнение массива с начала
{
    for (int i = 0; i < object.size; i++)
        cin >> object[i];
    return stream;
}
Safe &operator+ (Safe &object, int ADD) //Добавление размера
{
    int *temp = object.arr;
    object.arr = new int[object.size+ADD];
    for (int i = 0; i < object.size; i++)
        object.arr[i] = temp[i];
    object.size += ADD;
    object.how_add = ADD;
    delete[] temp;
    return object;
}
Safe &operator- (Safe &object, int ROB) //Уменьшение размера
{
    int *temp = object.arr;
    object.arr = new int[object.size-ROB];
    for (int i = 0; i < object.size-ROB; i++)
        object.arr[i] = temp[i];
    object.size -= ROB;
    delete[] temp;
    return object;
}
 
int main ()
{   setlocale(LC_ALL, "Russian");
 
    int SIZE, add;
    char choice = 'y', way;
 
    cout << "Размер массива: ";    cin  >> SIZE;
    Safe mass(SIZE); //Объект класса Safe – массив размера SIZE
 
    cout << "Заполнение: ";       cin >> mass;
    cout << "Просмотр массива: "     << mass << endl;
    while (true)
    {
        cout << endl << "Добавить размер: ";   cin >> add;     
        mass+add; //Увеличение размера массива. Перегруженный оператор +int
 
        again:
        cout << "Заполнение. С начала[b] или продолжать[c] : ";
        cin >> way;
        if (way == 'c')  { cout << "Продолжение: ";      mass.Set_to(); }
        else if (way == 'b') { cout << "С начала: ";     cin >> mass;   }
        else goto again;
 
        cout << "Обновленный массив: " << mass          << endl;
        cout << "Размер: "            << mass.View("size")     << endl;
        cout << "Сколько добавили: "   << mass.View("how_add") << endl;
        cout << "Continue? [y/n]: ";      cin >> choice;
        if (choice == 'y') continue;
        else break;
    }
    system("pause");
    return 0;
}

Queue::Queue(int m)
{
   // Получаем размер 
   maxturn = m;
   
   // Переменная timeturn не инициализирована
   Wait = new int[timeturn];
 
   // Правильный вариант
   Wait = new int[m];
   
   // Изначально очередь пуста
   timeturn = 0;
}