Передать значения закрытых переменных из класса в C++

Подскажите, пожалуйста, как мне передать параметры data, head, size и capacity в int main() для использования их в функции showQueueContects без использования геттеров и дружественных функций. В классе не должно появится новых методов.

#include <iostream>
#include <ctime>
#include <cstdlib>
#include <iomanip>

// Объявление класса "Очередь"
class Queue {
private:
  int* data; // Указатель на массив элементов очереди
  int head; // Индекс первого элемента в очереди
  int tail; // Индекс следующего за последним элемента в очереди
  int size; // Количество элементов в очереди
  int capacity; // Максимальный размер очереди

public:
  // Конструктор класса с параметром "c" - максимальным размером очереди
  Queue(int c) : head(0), tail(0), size(0), capacity(c) {
  data = new int[capacity]; // Выделение памяти под массив элементов очереди
}

// Переопределенный конструктор копирования
Queue(const Queue& other) : head(other.head), tail(other.tail), size(other.size), capacity(other.capacity) {
    data = new int[capacity]; // Выделение памяти под новый массив элементов очереди
    // Копирование элементов из исходной очереди в новую очередь
    for (int i = 0, j = head; i < size; j = (j + 1) % capacity) {
      data[i] = other.data[j];
    }
}

    // Деструктор класса
~Queue() {
    delete[] data; // Освобождение памяти, выделенной под массив элементов очереди
}
// Перегруженный оператор присваивания
Queue& operator=(const Queue& other) {
    if (this == &other) { // Проверка на самоприсваивание
        return *this;
    }
    // Очистка текущих данных
    delete[] data;
    // Копирование данных из исходной очереди
    head = other.head;
    tail = other.tail;
    size = other.size;
    capacity = other.capacity;
    data = new int[capacity]; // Выделение памяти под новый массив элементов очереди
    // Копирование элементов из исходной очереди в новую очередь
     for (int i = 0, j = head; i < size; j = (j + 1) % capacity) {
      data[i] = other.data[j];
    }
    return *this;
}

// Метод "push" для добавления элемента "element" в конец очереди
void push(int element) {
    if (size != capacity) { // Добавляем элемент в конец очереди и увеличиваем размер очереди на 1
        data[tail] = element; // Добавляем элемент в конец очереди
        tail = (tail + 1) % capacity; // Обновляем индекс "tail"
        size++; // Увеличиваем размер очереди на 1
    }
}

// Метод "pop" для удаления первого элемента из очереди и возврата его значения
int pop() {
    if (size == 0) { // Если очередь пуста, выводим сообщение об ошибке и возвращаем -1
        return -1;
    }

    int element = data[head]; // Запоминаем значение первого элемента
    head = (head + 1) % capacity; // Обновляем индекс "head"
    size--; // Уменьшаем размер очереди на 1
    return element; // Возвращаем значение удаленного элемента
}

    // Метод "empty" для получения значения пустой очереди
    bool empty() { 
        return size == 0;
    }

    // Метод "full" для получения значения переполненной очереди
    bool full() { 
        return size == capacity;
    }

    // Метод "peek" для неразрушающего чтения первого элемента очереди
    int peek() {
        return data[head]; // Возвращаем значение первого элемента очереди
    }

    // Геттеры
    int* get_Data(){ // Геттер на *data
      return data;
    }
    int get_Head(){ // Геттер на head
      return head;
    }
    int get_Size(){ // Геттер на size
      return size;
    }
    int get_Capacity(){ // Геттер на capacity
      return capacity;
    }
};

    //"showQueueContents" для отображения содержимого очереди
    void showQueueContents(const int* data, int head, int size, int capacity);

    // "PrintZerosInTime" для отображения нулей во временной шкале
    void PrintZerosInTime(int time);

int main(){
// Устанавливаем seed для генератора случайных чисел
srand(time(NULL));

// Максимальное количество вызовов в минуту и максимальный размер очереди
const int MAX_CALLS_PER_MINUTE = 2;
const int QUEUE_CAPACITY = 10;

// Создаем очередь и инициализируем другие переменные
Queue q(QUEUE_CAPACITY);
Queue other(q);
int time = 480; // 8:00 в минутах
int call_id = 0;
int end_time = 0;

// Выводим заголовок таблицы
std::cout << "время" << "\t" << "оператор" << "\t" << "звонки" << "\t" << "очередь" << std::endl;

while (time < 1200) { // 20:00 в минутах
  
    // Генерируем случайное количество вызовов
    int num_calls = rand() % (MAX_CALLS_PER_MINUTE + 1);
    int i = 0;
    while (i < num_calls) {
        if (q.full()) {
            // Если очередь переполнена, выводим сообщение
          if (time<=end_time) {
          PrintZerosInTime(time);
          std::cout <<"|занят|" << "\t"
          << "    |звонок " << call_id << " сброшен|" << "\t" 
          << "                        ";
          }
          else {
          PrintZerosInTime(time);
            std::cout <<"|свободен|" << "\t"
          << "    |звонок " << call_id << " сброшен|" << "\t" 
          << "                        ";
          }
          std::cout << "|Очередь переполненная|" << std::endl;
        }  if (!q.full()) {
            // Иначе добавляем звонок в очередь
            q.push(call_id);
            if (time<=end_time) {
          PrintZerosInTime(time);
          std::cout <<"|занят|" << "\t"
          << "    |звонок " << call_id << " принят|" << "\t" 
          << "                        ";
          }
          else {
          PrintZerosInTime(time);
            std::cout <<"|свободен|" << "\t"
          << "    |звонок " << call_id << " принят|" << "\t" 
          << "                        ";
          }
            showQueueContents(q.get_Data(), q.get_Head(), q.get_Size(), q.get_Capacity());
        } 
        call_id++;
        i++;
    } 
    if (!q.empty()) {
        // Если оператор свободен и есть вызовы в очереди, обрабатываем первый вызов
        int call = q.peek();
         if (time >= end_time) {// Проверяем, истекло ли время текущего вызова
           int call_time = rand() % 4 + 2; // длительность звонка от 2 до 5 минут
        end_time = time + call_time; // Сохраняем время окончания текущего вызова
        PrintZerosInTime(time);
          std::cout << "|занят|" << "\t" 
          << "|звонок " << call << " продлится (" << call_time << " мин)|" << "\t";
        if (q.pop() == -1) {
          std::cout << "|Очередь пуста|" << std::endl;
    }
        showQueueContents(q.get_Data(), q.get_Head(), q.get_Size(), q.get_Capacity());
    } else {
    // Если очередь пуста и оператор свободен, выводим информацию о текущем времени, состоянии операторов и отсутствии вызовов
            if (time<=end_time) {
            PrintZerosInTime(time);
          std::cout << std::setw(10) << "|занят|" << "\t" 
          << "|входящие вызовы отсутствуют|"       
          << "                        ";
          }
          else {
            PrintZerosInTime(time);
            std::cout << std::setw(10) << "|свободен|" << "\t" 
          << "|входящие вызовы отсутствуют|"       
          << "                        ";
          } 

    showQueueContents(q.get_Data(), q.get_Head(), q.get_Size(), q.get_Capacity());
}
// Увеличиваем время на одну минуту
    time++;
   }
}
    return 0;
}

    void showQueueContents(const int* data, int head, int size, int capacity) { 
      if (size == 0) {
          std::cout << "|Очередь пуста|" << std::endl;
        }
        else {std::cout << "|В ожидании: ";
        for (int i = 0; i < size; i++) {
            std::cout << data[(head + i) % capacity] << " ";
        }
        std::cout << "|" << std::endl;
             }
    }

    void PrintZerosInTime(int time) {
       std::cout << std::setfill('0') << std::setw(2) << time / 60 << ":" 
          << std::setfill('0') << std::setw(2) << time % 60 << "\t";
    }