printing a user input in Queues

[cplus2303]

How can we print user input variables including their ID, Name, and Pages of their document in Queue structure with an int main function?

#include<iostream>
#include <string>
template <typename T>
class Job{
private:
    int id = 0, pages = 0;
public:
    std::string name;
};

template <typename T>
class Printer{
private:
    T *q_array;
    int q_capacity;
    int q_size = 0, q_front = 0, q_back = 0;
public:
    Job<T> j;
    Printer(int newCapacity);
    bool isEmpty();
    int qSize();
    void displayFront();
    void displayBack();
    void enqueue(T newData);
    void dequeue();
    void clear();
    void displayAll();
    
    
    std::cout << " Please enter your Name " ;
    std::cin >> j.name;
    
    std::cout << " Enter the number of pages " ;
    std::cin>> j.pages;
    
    
    
    
};






template <typename T>
Printer<T>::Printer(int newCapacity){
    q_capacity = newCapacity;
    q_array = new T[q_capacity];
}

template <typename T>
bool Printer<T>::isEmpty(){
    return q_size == 0;
}

template <typename T>
int Printer<T>::qSize(){
    return q_size;
}

template <typename T>
void Printer<T>::displayFront(){
    std::cout << "Front: \t" << q_array[q_front%q_capacity] << std::endl;
    return;
}

template <typename T>
void Printer<T>::displayBack(){
    std::cout << "Back: \t" << q_array[q_back%q_capacity] << std::endl;
    return;
}

template <typename T>
void Printer<T>::clear(){
    q_size = 0;
    q_front = 0;
    q_back = 0;
}

template <typename T>
void Printer<T>::enqueue(T newData){
    std::string newName;
    j.name = newName;
    //check if full
    if(q_size==q_capacity){
        std::cout << "Queue is Full.\n";
        return;
    }

    //if empty
    if(isEmpty()){
        q_back = q_front;
        q_array[q_front%q_capacity] = newData;
        newName = newData;
        q_size++;
        return;
    }

    //if normal
    q_back++;
    q_array[q_back%q_capacity] = newData;
    newName = newData;
    q_size++;
    }

template<typename T>
void Printer<T>::dequeue(){
    T temp;
    //check if empty
    if(isEmpty()){
        std::cout << "Queue is Empty.\n";
        return;
    }

    //check if only one element
    if((q_front == q_back) && !(isEmpty())){
        temp = q_array[q_front%q_capacity];
        std::cout << temp << " was successfully dequeued.\n";
        clear();
        return;
    }

    //if normal
    temp = q_array[q_front++%q_capacity];
    //q_front++;
    std::cout << temp << " was successfully dequeued.\n";
    q_size--;
}

template <typename T>
void Printer<T>::displayAll(){
    std::cout << "Printing queue:\n";
    while(!isEmpty()){
        std::cout << q_array[q_front++%q_capacity];
        std::cout << "\n";
        q_size--;
    }
}

[seeplus]

Do you mean something like this (using the revised queue code from your previous post):

#include <iostream>
#include <string>

struct Job {
	int id {};
	std::string name;
	int pages {};
};

std::ostream& operator<<(std::ostream& os, const Job& j) {
	return os << j.id << ", " << j.name << ", " << j.pages;
}

template <typename T>
class Printer {
private:
	T* q_array {};
	size_t q_capacity {}, q_size {}, q_front {}, q_back {};

public:
	Printer(size_t newCapacity);
	bool isEmpty() const;
	bool isFull() const;
	size_t qSize() const;
	void displayFront() const;
	void displayBack() const;
	void enqueue(T newData);
	void dequeue();
	void clear();
	void displayAll() const;

	~Printer() {
		delete[] q_array;
	}

	// These need to be provided if needed
	Printer(const Printer&) = delete;
	Printer& operator=(const Printer&) = delete;
};

template <typename T>
Printer<T>::Printer(size_t newCapacity) : q_capacity { newCapacity }, q_array { new T[newCapacity] } {}

template <typename T>
bool Printer<T>::isEmpty() const {
	return q_size == 0;
}

template <typename T>
bool Printer<T>::isFull() const {
	return q_size == q_capacity;
}

template <typename T>
size_t Printer<T>::qSize() const {
	return q_size;
}

template <typename T>
void Printer<T>::displayFront() const {
	if (isEmpty())
		std::cout << "Queue is empty\n";
	else
		std::cout << "Front: " << q_array[q_front] << '\n';
}

template <typename T>
void Printer<T>::displayBack() const {
	if (isEmpty())
		std::cout << "Queue is empty\n";
	else
		std::cout << "Back: " << q_array[q_back ? (q_back - 1) : q_capacity - 1] << '\n';
}

template <typename T>
void Printer<T>::clear() {
	q_size = 0;
	q_front = 0;
	q_back = 0;
}

template <typename T>
void Printer<T>::enqueue(T newData) {
	if (isFull())
		std::cout << "Queue is Full.\n";
	else {
		q_array[q_back] = newData;
		q_back = (q_back + 1) % q_capacity;
		++q_size;
		//std::cout << newData << " was successfully enqueued.\n";
	}
}

template<typename T>
void Printer<T>::dequeue() {
	if (isEmpty())
		std::cout << "Queue is Empty.\n";
	else {
		const auto temp { q_array[q_front] };

		q_front = (q_front + 1) % q_capacity;
		--q_size;
		//std::cout << temp << " was successfully dequeued.\n";
	}
}

template<typename T>
void Printer<T>::displayAll() const {
	std::cout << "Printing queue\n";
	for (size_t i { q_front }, c {}; c < q_size; i = (i + 1) % q_capacity, ++c)
		std::cout << q_array[i] << '\n';

	std::cout << '\n';
}

int main() {
	Printer<Job> jobQ(10);

	jobQ.enqueue({1, "name1", 2});
	jobQ.enqueue({ 3, "name2", 4 });
	jobQ.displayAll();
}

which displays:

Printing queue
1, name1, 2
3, name2, 4

Obviously the output format can be changed as required.

[cplus2303]

thank you so much man :)