Comment utiliser la file d'attente C ++

Une file d'attente est une collection d'articles, où le premier élément ajouté dans la liste, doit être le premier élément à être supprimé ensuite. Ainsi, comme des articles sont ajoutés à la collection, il grandit en taille, je.e. il grandit en longueur. Chaque fois qu'un élément doit être supprimé, il doit être le premier ajouté. Si les éléments sont supprimés en continu, le suivant suivant est le deuxième élément; le troisième est supprimé par la suite, et ainsi de suite.

Une fois le premier élément de la liste d'origine, le second devient le premier élément. Une fois le deuxième élément supprimé, le troisième devient le premier élément, et ainsi de suite.

Un bon exemple réel d'une file d'attente est lorsque les gens s'alignent pour attendre le service ou le bien. La première personne est servie avant le dernier. Cependant, la file d'attente a parlé dans ce tutoriel, est la file d'attente du logiciel, comme conçu dans C++.

Fifo

FIFO signifie premier-in, première sortie. C'est une autre façon d'apprécier la file d'attente. Cela signifie que le premier élément à entrer dans la liste, est le premier élément à être supprimé, chaque fois que la suppression doit avoir lieu. Le début de la liste s'appelle la tête ou le front; La fin de la liste est appelée le dos ou la queue.

Opérations essentielles

Une file d'attente logicielle doit avoir au moins les opérations suivantes:

pousser

Cette opération ajoute un nouvel élément à l'arrière de la file d'attente. Cette opération est officiellement appelée, enquête.

changement

Cette opération supprime le premier élément de la file d'attente, et le deuxième élément devient le nouveau premier élément. Cette opération est officiellement appelée Dequeue. Il s'appelle Pop in C++.

Cet article explique comment utiliser la structure de données de file d'attente C ++. Vous devez connaître les pointeurs C ++ et les références pour comprendre le reste de cet article.

Classe et objets

Une classe est un ensemble de variables et de fonctions qui fonctionnent ensemble, où les variables n'ont pas de valeurs attribuées à. Lorsque des valeurs sont affectées aux variables, la classe devient un objet. Différentes valeurs données à la même classe entraînent différents objets; c'est-à-dire que différents objets sont la même classe avec des valeurs différentes. La création d'un objet à partir d'une classe est censée instanier l'objet.

Le nom, la file d'attente, est une classe. Un objet créé à partir de la classe de file d'attente a un nom choisi par le programmeur.

Une fonction qui appartient à une classe est nécessaire pour instancier un objet de la classe. En C ++, cette fonction a le même nom que le nom de la classe. Les objets créés (instanciés) à partir de la classe ont des noms différents qui leur sont donnés, par le programmeur.

La création d'un objet à partir de la classe signifie la construction de l'objet; Cela signifie également instanciation.

Un programme C ++ qui utilise la classe de file d'attente, commence par les lignes suivantes en haut du fichier:

#inclure
#inclure
Utilisation de Namespace Std;

La première ligne est pour l'entrée / sortie. La deuxième ligne est de permettre au programme d'utiliser toutes les fonctionnalités de la classe de file d'attente. La troisième ligne permet au programme d'utiliser les noms dans l'espace de noms standard.

Surchargez une fonction

Lorsque deux ou plusieurs signatures de fonction ont le même nom, ce nom est considéré comme surchargé. Lorsqu'une fonction est appelée, le nombre et le type d'arguments, déterminez quelle fonction est réellement exécutée.

Construction

file d'attente nom()

La déclaration suivante instancie une file d'attente nommée, que de type int.

file d'attente que;

La file d'attente est vide. La déclaration commence par le mot réservé, file d'attente suivie des supports d'angle avec le type de données. Ensuite, vous avez le prénom du programmeur pour la file d'attente.

Construction avec la liste d'initialiseur

La définition suivante montre comment créer une file d'attente avec la liste des initialiseurs:

file d'attente que (1.1, 2.2, 3.3, 4.4);

Détruire une file d'attente

Pour détruire une file d'attente, laissez-le sortir de la portée.

Accès à l'élément de file d'attente

push (valeur)

Une file d'attente est une liste de première sortie. Donc, chaque valeur est ajoutée à l'arrière. Le segment de code suivant crée une file d'attente vide, après quoi cinq valeurs flottantes sont ajoutées à l'arrière:

file d'attente que;
que ce soit.pousser (1.1);
que ce soit.pousser (2.2);
que ce soit.pousser (3.3);
que ce soit.pousser (4.4);
que ce soit.pousser (5.5);

taille () const

Cela renvoie le nombre d'éléments dans la file d'attente. Le code suivant illustre:

file d'attente que;
que ce soit.pousser (1.1); que ce soit.pousser (2.2); que ce soit.pousser (3.3); que ce soit.pousser (4.4); que ce soit.pousser (5.5);
couter << que.size() << '\n';

La sortie est 5.

devant()

Cela renvoie une référence au premier élément de la file d'attente, sans retirer l'élément. La sortie du code suivant est 1.1.

file d'attente que;
que ce soit.pousser (1.1); que ce soit.pousser (2.2); que ce soit.pousser (3.3); que ce soit.pousser (4.4); que ce soit.pousser (5.5);
couter << que.front() << '\n';

L'élément n'est pas supprimé de la file d'attente.

Front () const

Lorsque la construction de file d'attente est précédée par const, l'expression «front () const» est exécutée à la place de «Front ()». Il est utilisé dans le code suivant, par exemple.

file d'attente constante que (1.1, 2.2, 3.3, 4.4, 5.5);
couter << que.front() << '\n';

Une référence constante est retournée. L'élément n'est pas supprimé du vecteur. Les éléments de file d'attente ne peuvent pas être modifiés.

dos()

Cela renvoie une référence au dernier élément de la file d'attente, sans retirer l'élément. La sortie du code suivant est 5.5.

file d'attente que;
que ce soit.pousser (1.1); que ce soit.pousser (2.2); que ce soit.pousser (3.3); que ce soit.pousser (4.4); que ce soit.pousser (5.5);
couter << que.back() << '\n';

back () const

Lorsque la construction de file d'attente est précédée par const, l'expression «back () const» est exécutée à la place de «back ()». Il est utilisé dans le code suivant, par exemple.

file d'attente constante que (1.1, 2.2, 3.3, 4.4, 5.5);
couter << que.back() << '\n';

Une référence constante est retournée. L'élément n'est pas supprimé de la file d'attente. Avec la constante précédente pour la construction de file d'attente, les éléments de la file d'attente ne peuvent pas être modifiés.

Capacité de file d'attente

taille () const

- voir au dessus

vide () const

Cela renvoie 1 pour true s'il n'y a pas d'éléments dans la file d'attente, ou 0 pour false si la file d'attente est vide. Le code suivant illustre ceci:

file d'attente Que1 (1.1, 2.2, 3.3, 4.4, 5.5);
couter << que1.empty() << '\n';
file d'attente Que2;
couter << que2.empty() << '\n';

La sortie est:

0
1

Modificateurs de file d'attente

populaire()

Une file d'attente est FIFO, donc tout élément qui doit être supprimé doit être supprimé du haut (tête) de la file d'attente. Cette fonction membre supprime le premier élément sans le retourner. Le code suivant illustre ceci:

file d'attente que (1.1, 2.2, 3.3, 4.4, 5.5);
couter << que.front() << '\n';
que ce soit.populaire();
couter << que.size() << '\n';

La sortie est:

1.1
4

un.échange (b)

Deux files d'attente peuvent être échangées, comme illustré dans ce segment de code:

file d'attente Que1 (1.1, 2.2, 3.3, 4.4, 5.5);
file d'attente Que2 (10, 20);
que1.échange (Que2);
couter << "First element and size of que1:"
<< que1.front() <<", "<< que1.size() << '\n';
couter << "First element and size of que2 "<<
que2.devant() <<", "<< que2.size() << '\n';

La sortie est:

Premier élément et taille de Que1: 10, 2

Premier élément et taille de Que2: 1.1, 5

Notez que la longueur d'une file d'attente est augmentée si nécessaire. De plus, les valeurs qui n'avaient pas de remplacements sont remplacées par une valeur par défaut. Les types de données doivent être du même type.

Égalité et opérateurs relationnels pour les files d'attente

Pour les caractères ordinaires en C ++, dans l'ordre croissant, les chiffres viennent avant les lettres majuscules, qui se présentent avant les lettres minuscules. Le personnage de l'espace vient avant zéro et tous.

Opérateurs d'égalité

Retourne 1 pour true et 0 pour false.

L'opérateur ==

Renvoie 1 Si les deux files d'attente ont la même taille et que les éléments correspondants sont égaux; Sinon, il renvoie 0. Exemple:

file d'attente que1 ("kind", "autre chose");
file d'attente Que2 ("Wicked");
int num = que1 == Que2;
couter << num << '\n';

La sortie est: 0.

Le != Opérateur

- en face de ce qui précède. Exemple:

file d'attente que1 ("kind", "autre chose");
file d'attente Que2 ("Wicked");
int num = que1 != Que2;
couter << num << '\n';

La sortie est: 1.

Opérateurs relationnels

Retourne 1 pour true et 0 pour false.

Le < Operator

Renvoie 1 Si la première file d'attente est le sous-ensemble initial de la deuxième file d'attente, les éléments des deux parties égales étant identiques et dans le même ordre. Si les deux files d'attente sont de la même taille ou différentes tailles et se déplaçant de gauche à droite, un élément est rencontré dans la première file d'attente qui est inférieure à l'élément correspondant dans la deuxième file d'attente, alors 1 sera toujours retourné. Sinon 0 est retourné. Exemple:

file d'attente que1 ("kind", "autre chose");
file d'attente Que2 ("Wicked");
int num = que1 < que2;
couter << num << '\n';

La sortie est 1. < does not include the case when the size and order are the same.

L'opérateur>

- en face de ce qui précède. Exemple:

file d'attente que1 ("kind", "autre chose");
file d'attente Que2 ("Wicked");
int num = que1> que2;
couter << num << '\n';

Sortie: 0

Le <= Operator

- pareil que < but includes the case when the size and order are the same. Example:

file d'attente que1 ("kind", "autre chose");
file d'attente Que2 ("Wicked");
int num = que1 <= que2;
couter << num << '\n';

Sortie: 1

L'opérateur> =

- en face de ce qui précède. Exemple:

file d'attente que1 ("kind", "autre chose");
file d'attente Que2 ("Wicked");
int num = que1> = que2;
couter << num << '\n';

Sortie: 0

Classe et ses objets instanciés

Une valeur est à un type de données, car un objet instancié est pour une classe. La construction de file d'attente peut également accepter une classe comme type de données. Le programme suivant illustre ceci:

#inclure
#inclure
Utilisation de Namespace Std;
classe TheCla

public:
int num;
Char statique Ch;
void func (char cha, const char * str)
couter << "There are " << num << " books worth " <<
cha << str << " in the store." << '\n';

STATIC VOID FUN (char ch)
if (ch == 'a')
couter << "Official static member function" << '\n';

;
int main()
Thecla obj1; Thecla obj2; Thecla obj3; Thecla obj4; Thecla obj5;
file d'attente que;
que ce soit.push (obj1);
que ce soit.push (obj2);
que ce soit.push (obj3);
que ce soit.push (obj4);
que ce soit.push (obj5);
couter << que.size() << '\n';
retour 0;

La sortie est 5.

Liste liée

La liste des files d'attente est techniquement appelée une liste liée. Il existe deux types de listes liées pour la file d'attente: liste liée individuellement et liste doublement liée.

Un élément de liste lié seul peut être mis en œuvre par une structure de deux membres. Un membre détient un pointeur vers l'élément suivant et l'autre membre détient la donnée (singulière pour les données).

Un élément de liste doublement lié peut être mis en œuvre par une structure de trois membres. Le membre du milieu tient la donnée, tandis que les premier et troisième membres tiennent des pointeurs vers leurs éléments adjacents.

Applications de la file d'attente

La file d'attente est une structure de données premier entrée. Il y a des situations dans l'informatique lorsque les données arrivent sous la forme d'une file d'attente, nécessitant un comportement au premier entrée.

Partage des ressources informatiques

Une ressource dans un ordinateur est tout composant physique ou virtuel de la disponibilité limitée. Ils incluent le CPU, la carte vidéo, le disque dur et la mémoire. Partager une telle ressource a besoin d'une file d'attente.

Gestion des interruptions

Les périphériques informatiques doivent interrompre l'ordinateur de temps en temps. Les interruptions doivent être gérées de la même manière qu'ils sont arrivées. Cela a besoin d'une file d'attente.

Gérer les informations.

La file d'attente peut être utilisée, par exemple, pour gérer les fichiers d'application pour un travail, si les fichiers sont stockés dans l'ordinateur.

Conclusion

Une file d'attente est une structure de données de liste, qui est soit une liste liée individuellement, soit une liste à double liaison. En règle générale, le premier élément qui entre dans la liste est le premier élément à sortir. C ++ fournit une structure de données de file d'attente dans sa bibliothèque standard. Les catégories de fonctions et d'opérateurs des membres disponibles pour cette structure sont la construction de file d'attente, l'accès à l'élément de file d'attente, la capacité de file d'attente, les modificateurs de file d'attente et les opérateurs surchargés de file d'attente.

Toute structure de données de file d'attente doit fournir au moins, les fonctions de membre push () et pop (). push () signifie, envoyer un nouvel élément à l'arrière de la file d'attente; et pop () signifie, retirer l'élément qui se trouve à l'avant de la file d'attente. Malheureusement, en C ++, ces fonctions ne renvoient pas la valeur poussée ou éclatée. Ainsi, pour connaître le dernier élément avant de pousser, la fonction supplémentaire () doit être utilisée; Et pour connaître le premier élément avant de sauter, la fonction avant () supplémentaire doit être utilisée.

Une valeur est à un type de données, car un objet instancié est pour une classe. Ainsi, une classe particulière peut être utilisée comme type de données pour l'instanciation du modèle de file d'attente. Différents objets pour la classe deviennent comme des valeurs différentes pour la classe.

La file d'attente a des applications sur l'ordinateur. Il peut être utilisé, par exemple, pour gérer les fichiers d'application pour un travail, si les fichiers sont stockés dans l'ordinateur.