introduction
Une file d'attente est une collection d'éléments, où le premier élément ajouté à la liste doit être le premier élément à supprimer ensuite. Ainsi, à mesure que des articles sont ajoutés à la collection, sa taille augmente, je.e. il grandit en longueur. Chaque fois qu'un élément doit être supprimé, il doit être le premier ajouté. Si des éléments sont supprimés en continu, le suivant supprimé est le deuxième élément ; le troisième est retiré par la suite, et ainsi de suite.
Une fois le premier élément de la liste d'origine supprimé, 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 de file d'attente est lorsque les gens font la queue pour attendre un service ou une bonne. La première personne est servie avant la dernière. Cependant, la file d'attente dont il est question dans ce didacticiel est la file d'attente logicielle, telle que conçue en C++.
FIFO
FIFO signifie premier entré, premier sorti. 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 devant ; la fin de la liste s'appelle 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 à la fin de la file d'attente. Cette opération s'appelle officiellement, mettre en file d'attente.
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. C'est ce qu'on appelle pop en C++.
Cet article explique comment utiliser la structure de données de file d'attente C++. Vous devez connaître les pointeurs et références C++ pour comprendre la suite 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 affectées à. Lorsque des valeurs sont affectées aux variables, la classe devient un objet. Des valeurs différentes attribuées à la même classe donnent des objets différents ; 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 dite instancier l'objet.
Le nom, 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.
Créer un objet à partir de la classe signifie construire l'objet ; cela signifie aussi instancier.
Un programme C++ qui utilise la classe queue commence par les lignes suivantes en haut du fichier :
#inclure#inclure
en utilisant l'espace de noms std ;
La première ligne est pour l'entrée/sortie. La deuxième ligne permet 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.
Surcharger une fonction
Lorsque deux ou plusieurs signatures de fonction différentes ont le même nom, ce nom est dit surchargé. Lorsqu'une fonction est appelée, le nombre et le type d'arguments déterminent quelle fonction est réellement exécutée.
Construction
file d'attenteLa déclaration suivante instancie une file d'attente nommée, que de type int.
file d'attenteLa file d'attente est vide. La déclaration commence par le mot réservé, file d'attente suivi de chevrons avec le type de données. Ensuite, vous avez le nom du programmeur pour la file d'attente.
Construction avec la liste d'initialisation
La définition suivante montre comment créer une file d'attente avec une liste d'initialisation :
file d'attenteDétruire une file d'attente
Pour détruire une file d'attente, laissez-la simplement sortir de la portée.
Accès aux éléments de file d'attente
pousser (valeur)
Une file d'attente est une liste First-In-First-Out. Ainsi, 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'attenteque.pousser(1.1);
que.pousser(2.2);
que.pousser (3.3);
que.pousser (4.4);
que.pousser (5.5);
taille() const
Cela renvoie le nombre d'éléments dans la file d'attente. Le code suivant illustre :
file d'attenteque.pousser(1.1); que.pousser(2.2); que.pousser (3.3); que.pousser (4.4); que.pousser (5.5);
cout << que.size() << '\n';
La sortie est de 5.
de face()
Cela renvoie une référence au premier élément de la file d'attente, sans supprimer l'élément. La sortie du code suivant est 1.1.
file d'attenteque.pousser(1.1); que.pousser(2.2); que.pousser (3.3); que.pousser (4.4); que.pousser (5.5);
cout << que.front() << '\n';
L'élément n'est pas supprimé de la file d'attente.
avant() const
Lorsque la construction de la file d'attente est précédée de 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 constcout << que.front() << '\n';
Une référence constante est renvoyée. L'élément n'est pas supprimé du vecteur. Les éléments de la 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 supprimer l'élément. La sortie du code suivant est 5.5.
file d'attenteque.pousser(1.1); que.pousser(2.2); que.pousser (3.3); que.pousser (4.4); que.pousser (5.5);
cout << que.back() << '\n';
retour() const
Lorsque la construction de la file d'attente est précédée de 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 constcout << que.back() << '\n';
Une référence constante est renvoyée. L'élément n'est pas supprimé de la file d'attente. Avec le const précédent pour la construction de la file d'attente, les éléments de la file d'attente ne peuvent pas être modifiés.
Capacité de la file d'attente
taille() const
- voir au dessus
vide() const
Cela renvoie 1 pour vrai s'il n'y a pas d'éléments dans la file d'attente, ou 0 pour faux si la file d'attente est vide. Le code suivant illustre cela :
file d'attentecout << que1.empty() << '\n';
file d'attente
cout << que2.empty() << '\n';
La sortie est :
01
Modificateurs de file d'attente
pop()
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 cela :
file d'attentecout << que.front() << '\n';
que.pop();
cout << que.size() << '\n';
La sortie est :
1.14
une.échange(b)
Deux files d'attente peuvent être permutées, comme illustré dans ce segment de code :
file d'attentefile d'attente
que1.échange(que2) ;
cout << "First element and size of que1:
"<< que1.front() <<", "<< que1.size() << '\n';
cout << "First element and size of que2 "<<
que2.de face() <<", "<< 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 nombres précèdent les majuscules, qui précèdent les minuscules. Le caractère espace vient avant zéro et tous.
Opérateurs d'égalité
Renvoie 1 pour vrai et 0 pour faux.
L'opérateur ==
Renvoie 1 si les deux files d'attente ont la même taille et les éléments correspondants sont égaux ; sinon il renvoie 0. Exemple:
file d'attentefile d'attente
int num = que1 == que2;
cout << num << '\n';
La sortie est : 0.
le != Opérateur
- à l'opposé de ce qui précède. Exemple:
file d'attentefile d'attente
int num = que1 != que2;
cout << num << '\n';
La sortie est : 1.
Opérateurs relationnels
Renvoie 1 pour vrai et 0 pour faux.
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 les mêmes et dans le même ordre. Si les deux files d'attente sont de même taille ou de tailles différentes, et se déplaçant de gauche à droite, un élément est rencontré dans la première file d'attente qui est inférieur à l'élément correspondant dans la deuxième file d'attente, alors 1 sera toujours renvoyé. Sinon 0 est retourné. Exemple:
file d'attentefile d'attente
int num = que1 < que2;
cout << num << '\n';
La sortie est 1. < does not include the case when the size and order are the same.
L'opérateur >
- à l'opposé de ce qui précède. Exemple:
file d'attentefile d'attente
nombre entier = que1 > que2 ;
cout << num << '\n';
Sortie : 0
le <= Operator
- pareil que < but includes the case when the size and order are the same. Example:
file d'attentefile d'attente
int num = que1 <= que2;
cout << num << '\n';
Sortie : 1
L'opérateur >=
- à l'opposé de ce qui précède. Exemple:
file d'attentefile d'attente
int num = que1 >= que2;
cout << num << '\n';
Sortie : 0
Classe et ses objets instanciés
Une valeur est à un type de données, comme un objet instancié est à une classe. La construction de la file d'attente peut également accepter une classe comme type de données. Le programme suivant illustre cela :
#inclure#inclure
en utilisant l'espace de noms std ;
classe TheCla
Publique:
nombre entier ;
char ch statique;
void func (char cha, const char *str)
cout << "There are " << num << " books worth " << cha << str << " in the store." << '\n';
amusement du vide statique (char ch)
si (ch == 'a')
cout << "Official static member function" << '\n';
;
int main()
LeCla obj1; TheCla obj2; TheCla obj3; TheCla obj4; LeCla obj5;
file d'attente
que.pousser(obj1) ; que.pousser(obj2) ; que.pousser(obj3) ; que.pousser(obj4) ; que.pousser(obj5) ;
cout << que.size() << '\n';
renvoie 0 ;
La sortie est de 5.
Liste liée
La liste de file d'attente s'appelle techniquement une liste chaînée. Il existe deux types de listes chaînées pour la file d'attente : liste chaînée simple et liste chaînée double.
Un élément de liste chaînée peut être implémenté par une structure de deux membres. Un membre contient un pointeur vers l'élément suivant et l'autre membre contient la donnée (singulier pour les données).
Un élément de liste doublement chaîné peut être implémenté par une structure de trois membres. L'élément central contient la référence, tandis que les premier et troisième éléments contiennent 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é, premier sorti. Il existe des situations en informatique où les données arrivent sous la forme d'une file d'attente, nécessitant un comportement premier entré, premier sorti.
Partage de ressources informatiques
Une ressource dans un ordinateur est tout composant physique ou virtuel de disponibilité limitée. Ils comprennent le processeur, la carte vidéo, le disque dur et la mémoire. Le partage d'une telle ressource nécessite une file d'attente.
Gestion des interruptions
Les périphériques informatiques doivent interrompre l'ordinateur de temps en temps. Les interruptions doivent être traitées de la même manière qu'elles sont arrivées. Cela nécessite 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 à chaînage simple, soit une liste à chaînage double. 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 membres et d'opérateurs disponibles pour cette structure sont la construction de file d'attente, l'accès aux éléments de file d'attente, la capacité de file d'attente, les modificateurs de file d'attente et les opérateurs de file d'attente surchargée.
Toute structure de données de file d'attente doit fournir au moins les fonctions membres push() et pop(). push() signifie envoyer un nouvel élément à la fin de la file d'attente ; et pop() signifie supprimer l'élément qui se trouve au début de la file d'attente. Malheureusement, en C++, ces fonctions ne renvoient pas la valeur poussée ou sautée. Donc, pour connaître le dernier élément avant de pousser, la fonction extra back() doit être utilisée ; et pour connaître le premier élément avant d'apparaître, la fonction extra front() doit être utilisée.
Une valeur est à un type de données, comme un objet instancié est à 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.
Chrys