C++

Comment utiliser la file d'attente C++

Comment utiliser la file d'attente C++

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'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 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'attente que(1.1, 2.2, 3.3, 4.4);

Dé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'attente que;
que.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'attente que;
que.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'attente que;
que.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 const que (1.1, 2.2, 3.3, 4.4, 5.5);
cout << 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'attente que;
que.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 const que (1.1, 2.2, 3.3, 4.4, 5.5);
cout << 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'attente que1 (1.1, 2.2, 3.3, 4.4, 5.5);
cout << que1.empty() << '\n';
file d'attente que2;
cout << que2.empty() << '\n';

La sortie est :

0
1

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'attente que (1.1, 2.2, 3.3, 4.4, 5.5);
cout << que.front() << '\n';
que.pop();
cout << que.size() << '\n';

La sortie est :

1.1
4

une.échange(b)

Deux files d'attente peuvent être permuté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) ;
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'attente que1("genre", "quelque chose d'autre");
file d'attente que2("méchant");
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'attente que1("genre", "quelque chose d'autre");
file d'attente que2("méchant");
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'attente que1("genre", "quelque chose d'autre");
file d'attente que2("méchant");
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'attente que1("genre", "quelque chose d'autre");
file d'attente que2("méchant");
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'attente que1("genre", "quelque chose d'autre");
file d'attente que2("méchant");
int num = que1 <= que2;
cout << num << '\n';

Sortie : 1

L'opérateur >=

- à l'opposé de ce qui précède. Exemple:

file d'attente que1("genre", "quelque chose d'autre");
file d'attente que2("méchant");
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;
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

Remappez les boutons de votre souris différemment pour différents logiciels avec X-Mouse Button Control
Peut-être que vous avez besoin d'un outil qui pourrait faire changer le contrôle de votre souris avec chaque application que vous utilisez. Si tel est...
Examen de la souris sans fil Microsoft Sculpt Touch
J'ai lu récemment sur le Microsoft Sculpt Touch souris sans fil et j'ai décidé de l'acheter. Après l'avoir utilisé pendant un certain temps, j'ai déci...
Trackpad et pointeur de souris à l'écran AppyMouse pour tablettes Windows
Les utilisateurs de tablettes ratent souvent le pointeur de la souris, surtout lorsqu'ils ont l'habitude d'utiliser les ordinateurs portables. Les sma...