Hvordan bruke C ++ kø

En kø er en samling av elementer, der det første elementet som er lagt inn i listen, må være det første elementet som blir fjernet neste. Så når elementene legges til samlingen, vokser den i størrelse, jeg.e. det vokser i lengde. Hver gang noe vare skal fjernes, må det være den første lagt til. Hvis gjenstander fjernes kontinuerlig, er den neste fjernet, det andre elementet; Den tredje fjernes etterpå, og så videre.

Etter at den første varen på den opprinnelige listen er fjernet, blir den andre det første elementet. Etter at den andre varen er fjernet, blir den tredje det første varen, og så videre.

Et godt eksempel på en kø er når folk stiller opp for å vente på service eller god. Den første personen blir servert først før sist. Køen som er snakket om i denne opplæringen, er imidlertid programvarekøen, som designet i C++.

Fifo

FIFO står for første-inn, første-out. Det er en annen måte å sette pris på køen. Dette betyr at det første elementet som kommer inn i listen, er det første elementet som blir fjernet, når fjerning skal finne sted. Begynnelsen av listen kalles hodet eller fronten; slutten av listen kalles ryggen eller halen.

Essensielle operasjoner

En programvarekø må ha minst følgende operasjoner:

trykk

Denne operasjonen legger til et nytt element bak i køen. Denne operasjonen er offisielt kalt, Enqueue.

skifte

Denne operasjonen fjerner det første elementet i køen, og det andre elementet blir det nye første elementet. Denne operasjonen kalles offisielt Dequeue. Det kalles pop i C++.

Denne artikkelen forklarer hvordan du bruker datastrukturen C ++ kø. Du bør kjenne C ++ pekere og referanser for å forstå resten av denne artikkelen.

Klasse og gjenstander

En klasse er et sett med variabler og funksjoner som fungerer sammen, der variablene ikke har verdier tilordnet. Når verdier er tilordnet variablene, blir klassen et objekt. Ulike verdier gitt til samme klasse resulterer i forskjellige objekter; det vil si at forskjellige objekter er den samme klassen med forskjellige verdier. Å lage et objekt fra en klasse sies å instantisere objektet.

Navnet, kø, er en klasse. Et objekt opprettet fra køklassen har et programmerer valgt navn.

En funksjon som tilhører en klasse er nødvendig for å instantisere et objekt fra klassen. I C ++ har den funksjonen samme navn som navnet på klassen. Objekter opprettet (instantiert) fra klassen har forskjellige navn gitt dem, av programmereren.

Å lage et objekt fra klassen betyr å konstruere objektet; Det betyr også å instruentere.

Et C ++ -program som bruker køklassen, starter med følgende linjer øverst i filen:

#inkludere
#inkludere
ved hjelp av navneområdet STD;

Den første linjen er for inngang/utgang. Den andre linjen er å la programmet bruke alle funksjonene i køklassen. Den tredje linjen lar programmet bruke navnene i standard navneområdet.

Overbelastning av en funksjon

Når to eller flere forskjellige funksjonssignaturer har samme navn, sies det navnet å være overbelastet. Når en funksjon kalles, må du utføre antall og type argumenter som faktisk utføres.

Konstruksjon

kø Navn()

Følgende erklæring instantierer en kø som heter, Que of Type Int.

kø Que;

Køen er tom. Erklæringen begynner med det reserverte ordet, kø etterfulgt av vinkelbraketter med datatypen. Da har du programmererens fornavn for køen.

Konstruere med initializer -listen

Følgende definisjon viser hvordan du oppretter en kø med initializer -liste:

kø Que (1.1, 2.2, 3.3, 4.4);

Ødelegger en kø

For å ødelegge en kø, bare la den gå ut av omfang.

Køelementtilgang

Push (verdi)

En kø er en første-første-ut-ut-liste. Så hver verdi legges fra ryggen. Følgende kodesegment oppretter en tom kø, hvoretter fem flyteverdier legges fra baksiden:

kø Que;
Que.PUSH (1.1);
Que.Push (2.2);
Que.Push (3.3);
Que.PUSH (4.4);
Que.PUSH (5.5);

størrelse () const

Dette returnerer antall elementer i køen. Følgende kode illustrerer:

kø Que;
Que.PUSH (1.1); Que.Push (2.2); Que.Push (3.3); Que.PUSH (4.4); Que.PUSH (5.5);
cout << que.size() << '\n';

Utgangen er 5.

front()

Dette returnerer en referanse til det første elementet i køen, uten å fjerne elementet. Utgangen til følgende kode er 1.1.

kø Que;
Que.PUSH (1.1); Que.Push (2.2); Que.Push (3.3); Que.PUSH (4.4); Que.PUSH (5.5);
cout << que.front() << '\n';

Elementet fjernes ikke fra køen.

front () const

Når køkonstruksjonen er gitt av Const, blir uttrykket “front () const” utført i stedet for “front ()”. Den brukes i følgende kode, for eksempel.

const kø Que (1.1, 2.2, 3.3, 4.4, 5.5);
cout << que.front() << '\n';

En konstant referanse returneres. Elementet fjernes ikke fra vektoren. Køelementene kan ikke endres.

tilbake()

Dette returnerer en referanse til det siste elementet i køen, uten å fjerne elementet. Utgangen til følgende kode er 5.5.

kø Que;
Que.PUSH (1.1); Que.Push (2.2); Que.Push (3.3); Que.PUSH (4.4); Que.PUSH (5.5);
cout << que.back() << '\n';

Tilbake () const

Når køkonstruksjonen er gitt av Const, blir uttrykket “back () const” utført i stedet for “back ()”. Den brukes i følgende kode, for eksempel.

const kø Que (1.1, 2.2, 3.3, 4.4, 5.5);
cout << que.back() << '\n';

En konstant referanse returneres. Elementet fjernes ikke fra køen. Med den foregående konstanten for køkonstruksjonen kan ikke elementene i køen endres.

Køkapasitet

størrelse () const

- se ovenfor

tom () const

Dette returnerer 1 for sant hvis det ikke er noen elementer i køen, eller 0 for usant hvis køen er tom. Følgende kode illustrerer dette:

kø Que1 (1.1, 2.2, 3.3, 4.4, 5.5);
cout << que1.empty() << '\n';
kø Que2;
cout << que2.empty() << '\n';

Utgangen er:

0
1

Kømodifiserere

pop ()

En kø er FIFO, så ethvert element som må fjernes, må fjernes fra toppen (hodet) på køen. Denne medlemsfunksjonen fjerner det første elementet uten å returnere det. Følgende kode illustrerer dette:

kø Que (1.1, 2.2, 3.3, 4.4, 5.5);
cout << que.front() << '\n';
Que.pop ();
cout << que.size() << '\n';

Utgangen er:

1.1
4

en.Swap (b)

To køer kan byttes, som illustrert i dette kodesegmentet:

kø Que1 (1.1, 2.2, 3.3, 4.4, 5.5);
kø Que2 (10, 20);
Que1.Swap (Que2);
cout << "First element and size of que1:"
<< que1.front() <<", "<< que1.size() << '\n';
cout << "First element and size of que2 "<<
Que2.front() <<", "<< que2.size() << '\n';

Utgangen er:

Første element og størrelse på Que1: 10, 2

Første element og størrelse på Que2: 1.1, 5

Merk at lengden på en kø økes om nødvendig. Verdier som ikke hadde erstatning, erstattes også av noen standardverdi. Datatypene må være av samme type.

Likestilling og relasjonelle operatører for køer

For vanlige tegn i C ++, i stigende rekkefølge, kommer tall før store bokstaver, som kommer før små bokstaver. Romfiguren kommer før null og alle av dem.

Likestillingoperatører

Returnerer 1 for sann og 0 for falsk.

== operatøren

Returnerer 1 Hvis de to køene har samme størrelse og de tilsvarende elementene er like; ellers returnerer det 0. Eksempel:

kø Que1 ("Kind", "noe annet");
kø Que2 ("Wicked");
int num = Que1 == Que2;
cout << num << '\n';

Utgangen er: 0.

De != Operatør

- Motsatt av ovennevnte. Eksempel:

kø Que1 ("Kind", "noe annet");
kø Que2 ("Wicked");
int num = Que1 != Que2;
cout << num << '\n';

Utgangen er: 1.

Relasjonelle operatører

Returnerer 1 for sann og 0 for falsk.

De < Operator

Returnerer 1 Hvis den første køen er den første delmengden av den andre køen, med elementene i de to like store delene som er den samme og i samme rekkefølge. Hvis begge køene har samme størrelse eller forskjellige størrelser, og beveger seg fra venstre til høyre, oppstår et element i den første køen som er mindre enn det tilsvarende elementet i den andre køen, vil 1 fortsatt bli returnert. Ellers blir 0 returnert. Eksempel:

kø Que1 ("Kind", "noe annet");
kø Que2 ("Wicked");
int num = Que1 < que2;
cout << num << '\n';

Utgangen er 1. < does not include the case when the size and order are the same.

> Operatøren

- Motsatt av ovennevnte. Eksempel:

kø Que1 ("Kind", "noe annet");
kø Que2 ("Wicked");
int num = Que1> Que2;
cout << num << '\n';

Utgang: 0

De <= Operator

- samme som < but includes the case when the size and order are the same. Example:

kø Que1 ("Kind", "noe annet");
kø Que2 ("Wicked");
int num = Que1 <= que2;
cout << num << '\n';

Utgang: 1

> = Operatøren

- Motsatt av ovennevnte. Eksempel:

kø Que1 ("Kind", "noe annet");
kø Que2 ("Wicked");
int num = Que1> = Que2;
cout << num << '\n';

Utgang: 0

Klasse og dets instantierte objekter

En verdi er for en datatype, som et instantiert objekt er for en klasse. Køskonstruksjonen kan også godta en klasse som datatype. Følgende program illustrerer dette:

#inkludere
#inkludere
ved hjelp av navneområdet STD;
Klasse thecla

offentlig:
int num;
statisk char ch;
void func (char cha, const char *str)
cout << "There are " << num << " books worth " <<
cha << str << " in the store." << '\n';

statisk tomrom (char ch)
if (ch == 'a')
cout << "Official static member function" << '\n';

;
int main ()
Thecla obj1; Thecla obj2; Thecla obj3; Thecla obj4; Thecla obj5;
kø Que;
Que.push (obj1);
Que.push (obj2);
Que.push (obj3);
Que.push (obj4);
Que.push (obj5);
cout << que.size() << '\n';
retur 0;

Utgangen er 5.

Koblet liste

Kølisten kalles teknisk en koblet liste. Det er to typer koblede lister for køen: enkelt koblet liste og dobbelt koblet liste.

Et enkelt koblet listeelement kan implementeres av en struktur av to medlemmer. Det ene medlemmet holder en peker til neste element, og det andre medlemmet holder datumet (entall for data).

Et dobbelt koblet listeelement kan implementeres av en struktur på tre medlemmer. Midtmedlemmet holder nøye, mens det første og tredje medlemmene holder pekere til sine tilstøtende elementer.

Applikasjoner av køen

Køen er en første-første-ut-ut-datastruktur. Det er situasjoner i databehandling når data kommer i form av en kø, noe som nødvendiggjør første-første-ut-ut-oppførsel.

Dele datamaskinressurser

En ressurs i en datamaskin er noen fysisk eller virtuell komponent av begrenset tilgjengelighet. De inkluderer CPU, skjermkort, harddisk og minne. Å dele en slik ressurs trenger kø.

Håndtering av avbrytelser

Periferiutstyr for datamaskiner må avbryte datamaskinen fra tid til annen. Avbruddene må håndteres på samme måte som de ankom. Dette trenger en kø.

Administrer informasjon.

Køen kan for eksempel brukes til å administrere applikasjonsfiler for en jobb, hvis filene er lagret på datamaskinen.

Konklusjon

En kø er en listedatastruktur, som enten er en enkelt koblet liste eller en dobbeltbundet liste. Som regel er det første elementet som kommer inn i listen det første elementet som kommer ut. C ++ gir en kø datastruktur i standardbiblioteket. Kategoriene av medlemsfunksjoner og operatører som er tilgjengelige for denne strukturen er køskonstruksjon, køelementtilgang, køekapasitet, kømodifiserere og køoverbelastede operatører.

Enhver kø -datastruktur må i det minste gi, PUSH () og POP () medlemsfunksjoner. Push () betyr å sende et nytt element bak i køen; og pop () betyr å fjerne elementet som er foran i køen. Dessverre, i C ++, returnerer ikke disse funksjonene verdien som er presset eller poppet. Så for å kjenne det siste elementet før du skyver, må den ekstra bak () -funksjonen brukes; Og for å kjenne det første elementet før du popper, må den ekstra front () -funksjonen brukes.

En verdi er for en datatype, som et instantiert objekt er for en klasse. Så en bestemt klasse kan brukes som en datatype for kømalens instantiering. Ulike objekter for klassen blir som forskjellige verdier for klassen.

Køen har applikasjoner på datamaskinen. Det kan for eksempel brukes til å administrere applikasjonsfiler for en jobb, hvis filene er lagret på datamaskinen.