Next
1. Vector Basics2. Vector Operations3. 2D Vector4. Map Basics5. Set Basics6. Unordered Map and Set7. Stack Basics8. Queue Basics9. Priority Queue10. Deque (Double-ended Queue)

Queue Basics in C++

Basic Queue Operations in C++.

BeginnerSTL Containers ProgramsExample 8 of 10
queue-basics.cpp
1#include <iostream>
2#include <queue>
3using namespace std;
4

5int main() {
6    // Create queue
7    queue<int> q;
8    
9    // Enqueue elements
10    q.push(10);
11    q.push(20);
12    q.push(30);
13    q.push(40);
14    q.push(50);
15    
16    cout << "Queue size: " << q.size() << endl;
17    cout << "Front element: " << q.front() << endl;
18    cout << "Back element: " << q.back() << endl;
19    
20    // Display queue (by dequeuing)
21    cout << "\nQueue elements (FIFO - First In First Out):" << endl;
22    while (!q.empty()) {
23        cout << q.front() << " ";
24        q.pop();
25    }
26    cout << endl;
27    
28    // Queue for BFS-like processing
29    queue<string> taskQueue;
30    
31    taskQueue.push("Task 1");
32    taskQueue.push("Task 2");
33    taskQueue.push("Task 3");
34    
35    cout << "\nProcessing tasks:" << endl;
36    while (!taskQueue.empty()) {
37        cout << "Processing: " << taskQueue.front() << endl;
38        taskQueue.pop();
39    }
40    
41    return 0;
42}

Output

Queue size: 5
Front element: 10
Back element: 50

Queue elements (FIFO - First In First Out):
10 20 30 40 50

Processing tasks:
Processing: Task 1
Processing: Task 2
Processing: Task 3

What's going on

The program demonstrates queue operations:

Creating queue and enqueuing elements
Accessing front and back elements
Dequeuing elements (FIFO order)
Task processing simulation

Queues provide simple, efficient first-in-first-out data access.

Header Files Used

1.#include <iostream>
Provides cout and cin for input/output operations.
2.#include <queue>
Provides queue container class.

Understanding Queue

FIFO Concept

:

First In First Out
First element added is first removed
Like a line of people
Front and back accessible

Key Features

:

Simple operations
O(1) time complexity
First-in-first-out order
Front and back accessible

Queue Operations

push()

(Enqueue):

q.push(10); // Add to back

pop()

(Dequeue):

q.pop(); // Remove from front

front()

:

int value = q.front(); // Access front element

back()

:

int value = q.back(); // Access back element

How it works

:

push(): adds to back
pop(): removes from front
front(): returns front element
back(): returns back element
All O(1) operations

Queue Properties

Size and Empty

:

q.size() // Number of elements

q.empty() // True if empty

Access

:

Front: first element (oldest)
Back: last element (newest)
Cannot access middle elements
FIFO order enforced

Task Processing

Using Queue

:

1.Add tasks to queue
2.Process front task
3.Remove processed task
4.Repeat until empty

How it works

:

Tasks processed in order
First added = first processed
Natural for scheduling
Maintains order

When to Use Queue

Best For

:

BFS (Breadth-First Search)
Task scheduling
Print queue management
Message buffering
Order processing
Level-order traversal

Example Scenarios

:

Graph BFS algorithm
Task scheduler
Print queue
Message queue
Request processing
Event handling

Important Considerations

FIFO Order

:

First added = first removed
Maintains insertion order
Cannot access arbitrary elements
Natural for sequential processing

Performance

:

All operations: O(1)
Very efficient
Simple implementation
Minimal overhead

Limitations

:

Only front and back accessible
Cannot search or access middle
Must dequeue to access other elements
Use other containers if random access needed

return 0;

This ends the program successfully.

PreviousStack BasicsNextPriority Queue