freeCodeCamp/guide/portuguese/cplusplus/queue/index.md

title	localeTitle
queue	fila

Filas

queue é um dos contêineres mais usados ​​em C ++. Um contêiner é uma estrutura de dados que armazena uma coleção de objetos, alguns em ordem, outros não. Todos os contêineres possuem um conjunto diferente de funções que permitem acessar um objeto (s) nessa coleção.

std::queue faz parte da biblioteca padrão C ++ (daí o prefixo std:: e permite que você armazene dados na ordem First In First Out (FIFO). NOTA: Todos os objetos em uma fila devem ser do mesmo tipo de dados

O tipo de dados armazenado em uma fila fica entre colchetes angulares ao lado da palavra-chave da fila. Por exemplo, se você gostaria de armazenar uma coleção de inteiros, a fila seria std::queue<int> queue_name

Explicação LIFO da fila

queue nos permite enviar / enfileirar e colocar / soltar em ordem específica. Empurrar significa inserir um objeto na frente da fila. Pop significa retirar o objeto "mais antigo" do final da fila. Então, quando você empurra, está na frente e, quando você abre, extrai o elemento mais antigo.

Operações de fila

O contêiner de filas suporta as seguintes operações:

• empurrar (enfileirar)
• pop (dequeue)
• vazio
• Tamanho
• frente
• costas

Empurrar

Permite inserir um novo elemento no final da fila, depois do último elemento atual.

//Push operation in Queue 
 #include <iostream>       // std::cout 
 #include <queue>          // std::queue 
 
 int main () 
 { 
  std::queue<int> q; 
 
  q.push(1);    //Pushing 1 at front of the queue 
  q.push(2);    //Pushing 2 at front of the queue 
 
  return 0; 
 } 

Frente

Permite que você acesse o próximo elemento na fila sem removê-lo. O próximo elemento é o elemento "mais antigo" na fila.

//Front operation in Queue 
 #include <iostream>       // std::cout 
 #include <queue>          // std::queue 
 
 int main () 
 { 
  std::queue<int> q; 
 
  q.push(1);    //Pushing 1 at front of the queue 
  q.push(2);    //Pushing 2 at front of the queue 
 
  std::cout<<q.front()<<'\n';     //Accessing the front of the queue 
  std::cout<<q.front()<<'\n';     //Accessing the front of the queue 
 
  return 0; 
 } 

Output: 
 1 
 1 

Pop

Permite que você remova o próximo elemento na fila, reduzindo efetivamente seu tamanho em um. O elemento removido é o elemento "mais antigo".

//Pop operation in Queue 
 #include <iostream>       // std::cout 
 #include <queue>          // std::queue 
 
 int main () 
 { 
  std::queue<int> q; 
 
  q.push(1);    //Pushing 1 at front of the queue 
  q.push(2);    //Pushing 2 at front of the queue 
 
  std::cout<<q.front()<<'\n';     //Accessing the front of the queue 
  q.pop();                        //Removing the oldest element 
  std::cout<<q.front()<<'\n';     //Accessing the front of the queue 
  q.pop();                        //Removing the oldest element 
 
  return 0; 
 } 

Output: 
 1 
 2 

Tamanho

Retorna o número de elementos na queue .

//Size operation in Queue 
 #include <iostream>       // std::cout 
 #include <queue>          // std::queue 
 
 int main () 
 { 
  std::queue<int> q; 
 
  q.push(1);    //Pushing 1 at front of the queue 
  q.push(2);    //Pushing 2 at front of the queue 
 
  std::cout<<q.size()<<'\n';     //Accessing the front of the queue 
  q.pop();                        //Removing the oldest element 
  std::cout<<q.size()<<'\n';     //Accessing the front of the queue 
  q.pop();                        //Removing the oldest element 
  std::cout<<q.size()<<'\n';     //Accessing the front of the queue 
 
  return 0; 
 } 

Output: 
 2 
 1 
 0 

Vazio

Retorna se a queue está vazia, ou seja, se o tamanho da sua fila é zero. Retorna true se o tamanho da fila 0 retornar mais false

`` `cpp // Operação vazia na fila

incluir // std :: cout

incluir // std :: stack

int main () { std :: queue q;

q.push (1); q.push (2);

while (q.empty ()! = true) { std :: cout << q.front () << '\ n'; q.pop (); }

std :: cout << "Fora de loop" << '\ n'; return 0; }

    Output: 
    1 
    2 
    Out of loop 
 
 #### Back 
 
 Allows you to access the last element in the queue without removing it. 
 The next element is the "newest" element in the queue. 

cpp // Voltar operação na fila

incluir // std :: cout

incluir // std :: queue

int main () { std :: queue q;

q.push (1); // Empurrando 1 na frente da fila q.push (2); // Empurrando 2 na frente da fila

std :: cout << q.back () << '\ n'; // Acessando a parte de trás da fila std :: cout << q.back () << '\ n'; // Acessando a parte de trás da fila

return 0; } `` `

Output: 
 2 
 2 

Para mais recursos:

http://www.cplusplus.com/reference/queue/queue/

Citações:

Imagem Cortesia: https://en.wikipedia.org/wiki/FIFO (computação and_electronics)