Queue Data Structure in C++: FIFO Concepts & Code Examples

By -

Introduction

A queue is a linear data structure in C++ that follows the FIFO (First In, First Out) principle. This means the element that is inserted first is the first one to be removed. Queues are widely used in real-world applications such as task scheduling, printer management, buffering data, and handling requests in operating systems. In C++, queues can be implemented using arrays, linked lists, or by using the built-in queue container provided by the Standard Template Library (STL). Learning queues helps beginners understand orderly data processing and efficient resource management.

Let’s Explore the Queue Data Structure in C++

Today, we going to create Queues in C++. A queue in C++ is a linear data structure that follows FIFO (First In, First Out), where the first element added is the first one removed. It can be implemented in C++ using arrays or linked lists.

There are four types of Queues:

  1. Simple Queue – Elements are inserted at the rear and removed from the front.

  2. Circular Queue – The last position connects to the first to efficiently use space.

  3. Priority Queue – Elements are removed based on priority, not order.

  4. Double-Ended Queue (Deque) – Insertion and deletion can occur at both ends.

Queue using Array

An array-based queue stores elements in a fixed-size array using two indices, front and rear. Elements are added at the rear and removed from the front. It is fast and simple, but its size is limited and may waste space unless a circular queue is used. This is an example code of a simple queue using array:
#include <iostream>
using namespace std;

#define SIZE 5

class Queue {
    int arr[SIZE];
    int front, rear;

public:
    Queue() {
        front = -1;
        rear = -1;
    }

    void enqueue(int x) {
        if (rear == SIZE - 1) {
            cout << "Queue Overflow\n";
            return;
        }
        if (front == -1)
            front = 0;
        arr[++rear] = x;
    }

    void dequeue() {
        if (front == -1 || front > rear) {
            cout << "Queue Underflow\n";
            return;
        }
        cout << "Deleted: " << arr[front++] << endl;
    }

    void display() {
        for (int i = front; i <= rear; i++)
            cout << arr[i] << " ";
        cout << endl;
    }
};

int main() {
    Queue q;
    q.enqueue(10);
    q.enqueue(20);
    q.enqueue(30);
    q.display();
    q.dequeue();
    q.display();
    return 0;
}

Now, here's another code with overall program to understand it better:

As shown in the above image, this code creates a queue using an array inside a class. The variables front and rear keep track of where elements are removed and added. When enqueue() is called, a new element is added at the rear of the array. When dequeue() is called, the element at the front is removed. If the queue is full, it shows overflow, and if it is empty, it shows underflow. The size of the queue is fixed when the object is created.

Queue using Linked List

A linked list–based queue uses nodes connected by pointers. It also has front and rear pointers for removal and insertion. This type can grow dynamically and does not waste space, but it uses extra memory for pointers. This is an example code of a simple queue using linked list:
#include <iostream>
using namespace std;

struct Node {
    int data;
    Node* next;
};

class Queue {
    Node *front, *rear;

public:
    Queue() {
        front = rear = NULL;
    }

    void enqueue(int x) {
        Node* temp = new Node();
        temp->data = x;
        temp->next = NULL;

        if (rear == NULL) {
            front = rear = temp;
            return;
        }
        rear->next = temp;
        rear = temp;
    }

    void dequeue() {
        if (front == NULL) {
            cout << "Queue Underflow\n";
            return;
        }
        Node* temp = front;
        cout << "Deleted: " << front->data << endl;
        front = front->next;
        delete temp;

        if (front == NULL)
            rear = NULL;
    }

    void display() {
        Node* temp = front;
        while (temp != NULL) {
            cout << temp->data << " ";
            temp = temp->next;
        }
        cout << endl;
    }
};

int main() {
    Queue q;
    q.enqueue(10);
    q.enqueue(20);
    q.enqueue(30);
    q.display();
    q.dequeue();
    q.display();
    return 0;
}

Now, here's the overall program of another code to understand it better:

As shown in the above image, this code implements a queue using a linked list. Each element is stored in a node containing data and a pointer to the next node. The front pointer is used to remove elements, and the rear pointer is used to add new elements. enqueue() adds a new node at the end of the list, and dequeue() removes the node from the front. This queue can grow dynamically and does not have a fixed size.

Important Notes (Things Beginners Often Miss with Queues in C++)

A very common beginner mistake is confusing FIFO with LIFO. Unlike stacks, queues always remove the element that was inserted first. Remember: insertion happens at the rear, and deletion happens at the front—never the other way around.

Another frequent issue is not handling overflow and underflow properly. In array-based queues, trying to enqueue when the queue is full causes overflow, and trying to dequeue when it’s empty causes underflow. Always check conditions like rear == SIZE - 1 or front == -1 before performing operations.

Beginners also often forget that simple array queues can waste space. After several dequeue operations, unused space appears at the front of the array. This is why circular queues are important—they reuse empty spaces efficiently instead of shifting elements.

In linked-list-based queues, a common mistake is not updating both front and rear correctly. When the last element is removed, both pointers must be set to NULL. Forgetting this can lead to dangling pointers and runtime errors.

Another overlooked detail is accessing queue elements without checking if the queue is empty. Calling dequeue or reading front data when front == NULL can crash the program. Defensive checks make your code safer and more professional.

Lastly, beginners sometimes underestimate queues’ importance. Queues are heavily used in real systems, including CPU scheduling, networking, printer queues, and breadth-first search (BFS). Understanding queues early makes it much easier to learn operating systems, graphs, and real-time applications later on.

Mastering queues—along with stacks—gives you a strong foundation in data flow and algorithm design in C++.

Conclusion

Queues are an essential data structure for managing data in a sequential and organized manner. Their FIFO behavior makes them ideal for applications where fairness and order matter. By understanding queues in C++, beginners develop strong problem-solving skills and gain insight into how real-time systems handle tasks. Mastering queues also builds a solid foundation for advanced concepts such as circular queues, priority queues, and breadth-first search algorithms.

Comments

Post a Comment

Popular posts from this blog

Numbers & Numeric Operations in C++: Data Types & cmath Functions

By -
Image
Introduction Numbers are at the core of almost every C++ program, whether you’re performing calculations, storing values, managing user input, or building complex logic. C++ provides several numeric data types—such as int , float , double , and long —to handle different kinds of numerical information efficiently. Understanding how these numbers work, how they are stored, and how to perform operations on them is essential for beginners. In this blog post, we’ll explore the different types of numbers in C++, how they behave, and how you can use them to perform mathematical tasks in your programs. Let’s Explore Numbers & Numeric Operations in C++ Today, we are performing mathematical operations in C++. We will include the include<cmath> library in our code, this library gives us a lot of functions, and methods that help us to perform mathematical operations. In this post, we are going to learn about functions like fmin(*, *) fmax(*, *) floor(*) ceil(*) and round(*...
Read more

Introduction to C++: Your First Program & Hello World

By -
Image
Introduction Programming always begins with a simple but powerful first step — printing “Hello, World!” to the screen. For beginners, this small program acts as an introduction to the basic structure, syntax, and workflow of a programming language. In C++, the “ Hello World ” program helps new learners understand how a C++ program is written, compiled, and executed. In this post, we’ll look at the C++ code for printing “ Hello World ”, break down every part of it, and explain how it works in the simplest way possible. Let’s Write Your First C++ Program Today we are learning about cout and endl Cout stands for " Console out " and endl stands for " End line ". Overall, We use cout to print output in our console and endl to start a new line after the execution of each cout. Using endl is optional but cout is mandatory to get output in our console. Also, we use the " << " sign when we use cout and endl. The overall statement looks like this: cout ...
Read more

Intro to C++ for Beginners

By -
Image
Hi, I’m Taiel , the writer of this blog, and this is the first post on C++ in the tech and programming blog . Let’s get started without any delay. If you’re new to C++, you don’t need any heavy setup at first. For practice, you can use tools like OnlineGDB, Programmiz, Scrimba, or Visual Studio . These platforms allow you to write, compile, and run C++ programs easily, making them perfect for beginners. Introduction C++ is a high-level, general-purpose programming language created by Bjarne Stroustrup . It was first released in 1985 as an extension of the C language. The main goal was to add more flexibility and features, such as object-oriented programming , while maintaining performance and efficiency. Over time, C++ has evolved to include templates for generic programming , functional programming support , and low-level memory control . Because of these features, it is widely used to build performance-critical systems such as operating systems and embedded software . C++ is a comp...
Read more

User Input in C++: Reading Data from Keyboard with cin & getline()

By -
Image
Introduction Getting user input is an essential part of making interactive C++ programs. Instead of displaying fixed outputs, programs can ask users for information—such as numbers, names, or choices—and respond based on those inputs. In C++, user input is commonly taken using the cin object along with the extraction operator ( >> ). This allows beginners to easily read values like integers, floating-point numbers, characters, and even entire strings. In this blog post, we’ll explore how user input works in C++, look at important functions, and understand how to handle input safely and correctly. Let’s Explore User Input in C++ Today, We are getting the user input and printing it out in a very creative manner. This is not only going to teach you how to get user input but also how to print them with strings, where the string is set as default. To get user input, we use cin meaning console in , and instead of using this sign << we will use this sign >> to get user...
Read more

Mad Libs Game in C++: Build Your First Interactive Program

By -
Image
Introduction One of the best ways to understand the basics of C++ is by building small, fun projects—and a Mad Libs game is a perfect example. This simple word-based game lets users enter different types of words like nouns, verbs, or adjectives, and the program places them into a story template to create a funny or unexpected result. By making a Mad Libs game in C++, beginners can practice key concepts such as variables, strings, user input, and output formatting. In this blog post, we’ll walk through how a basic Mad Libs program works and how it helps strengthen your overall understanding of C++. Let’s Build a Mad Libs Game in C++ Today, we are going to make a Mad Libs Game using C++ . To make the game, we are going to use the combinations of getline(); //function and cout //in our text editor Now, Here's our code, so you can understand better: As you can see, Our game is ready to play. Important Notes While building a simple game like Mad Libs in C++, beg...
Read more

Strings in C++: Basics, Methods & Examples

By -
Image
Introduction Strings are one of the most useful and frequently used features in C++ programming. They allow us to store and work with text, such as names, messages, sentences, and any sequence of characters. In C++, strings can be handled using both character arrays ( char[] ) and the modern string class from the Standard Library, which makes working with text much easier. In this blog, we’ll explore what strings are, how they work in C++, and look at practical examples of declaring, modifying, and accessing string data. Understanding strings is essential for building real-world applications like user input systems, text processing tools, and interactive programs. Let’s Explore Strings in C++ Today, we are learning about some methods, indexing characters, and replacing some letters without needing to rewrite the code. Also, we will use " \n " in some places instead of " endl " to print a new line in our code. Index numbers in programming languages start from 0 li...
Read more

Variables & Data Types in C++: Basics with Examples

By -
Image
Introduction Understanding variables and data types is one of the first and most important steps in learning C++. Variables act as containers that store different kinds of information, while data types define what kind of values those variables can hold—such as numbers, characters, or true/false values. Together, they form the foundation of every C++ program. In this blog, we’ll explore what variables are, why data types matter, and how C++ uses a variety of types like int , float , char , bool , and more. This topic is essential for beginners who want to write efficient, error-free programs. Let’s Explore Variables & Data Types in C++ Today, We are learning about Data Types and Variables , and how to use them in C++. In programming languages we use variables most of the time, variables are like boxes that contain elements like sentences, characters, integers, decimals, and boolean values . Variables are defined into multiple types, also known as Data Types. In the case of data t...
Read more

Printing Patterns in C++: Shape Output with Loops & Logic

By -
Image
Introduction Printing shapes using C++ is a fun and effective way for beginners to practice loops, conditions, and pattern-building logic. Whether it’s a square, triangle, pyramid, or diamond, these patterns help new programmers understand how nested loops work and how characters like * , # , or numbers can be arranged to create visual output. In this blog post, we’ll explore how to print different shapes in C++, look at the code behind them, and explain how the loops interact to form each pattern. This is one of the best ways to strengthen logical thinking and improve your problem-solving skills in C++. Let’s Print Patterns with Loops in C++ Today, we will print out shapes like pyramids and stairs using C++. It means today we are going to use this in multiple sentence: cout << * << endl; Yesterday, In the printing "Hello World" using C++  blog post we used this sentence only once but today we are going to use it multiple times, so if any of you don't know h...
Read more

Return Statement in C++: Syntax, Purpose & Examples

By -
Image
Introduction The return statement is one of the most important parts of a C++ function. It allows a function to send a value back to the place where it was called and also marks the end of the function’s execution. Whether you are working with simple functions or building more complex programs, understanding how the return statement works is essential. In this blog, we’ll explore what the return statement does, why it is used, how it behaves in different types of functions, and how it helps in writing cleaner and more efficient C++ code. This topic is crucial for beginners who want to strengthen their function-related concepts. Let’s Explore the Return Statement in C++ Today, we are going to return results from functions to main function. It is very easy to use return statement but return statement doesn't works on void() function. This is an example of return statement: return A; Where " A " is a variable and the word " return " passes the outcome from the ...
Read more

Functions in C++: Syntax, Use & Examples

By -
Image
Introduction Functions are one of the most important concepts in C++ because they allow you to break your program into smaller, manageable pieces. Instead of writing all your code inside the main() function, you can create separate blocks of code—called functions—that perform specific tasks. This makes your program easier to read, understand, reuse, and debug. In this blog post, we’ll explore what functions are, how they work in C++, the different types of functions, and why they are essential for writing clean and organized programs. Whether you're a beginner or building your first projects, understanding functions will significantly improve your coding skills. Let’s Explore Functions in C++ Today, we are going to create Functions . Functions performs a set of commands by using a set of data, e.g. int main() //It is also a kind of a function which runs some of our commands in our program. Functions are very helpful as we don't need to create same commands multiple time, he...
Read more