Bevezetés
A sor az elemek gyűjteménye, ahol a listába először felvett elemnek kell az elsőként eltávolítandó elemnek lennie. Tehát ahogy a tárgyak felkerülnek a gyűjteménybe, egyre nagyobb a mérete, azaz nő a hossza. Amikor egy elemet el kell távolítani, azt először hozzá kell adni. Ha az elemeket folyamatosan eltávolítják, akkor a következő eltávolítás a második elem; a harmadikat később eltávolítják, és így tovább.
Az eredeti lista első elemének eltávolítása után a második lesz az első elem. A második elem eltávolítása után a harmadik lesz az első elem, és így tovább.
A sor valós példája a valós életben, amikor az emberek sorban állnak, hogy megvárják a szolgáltatást vagy a jót. Az első személyt szolgálják ki először az utolsó előtt. Azonban a sor, amelyről ebben az oktatóanyagban szó esett, a szoftversor, a C ++ nyelven tervezett módon.
FIFO
A FIFO rövidítés: First-In, First-Out. Ez egy másik módja a sor felmérésének. Ez azt jelenti, hogy az első elem, amely belép a listába, az első eltávolítandó elem, amikor eltávolításra kerül sor. A lista elejét fejnek vagy frontnak nevezik; a lista végét hátsónak vagy faroknak nevezik.
Alapvető műveletek
A szoftversornak legalább a következő műveleteket kell végrehajtania:
nyom
Ez a művelet egy új elemet ad hozzá a sor hátuljához. Ezt a műveletet hivatalosan enqueue -nak hívják.
váltás
Ez a művelet eltávolítja a sor első elemét, és a második elem lesz az új első elem. Ezt a műveletet hivatalosan dequeue -nak hívják. C ++ - ban popnak hívják.
Ez a cikk elmagyarázza, hogyan kell használni a C ++ várólista adatstruktúráját. Tudnia kell a C ++ mutatókat és hivatkozásokat a cikk többi részének megértéséhez.
Osztály és tárgyak
Az osztály olyan változók és függvények együttese, amelyek együtt működnek, és ahol a változókhoz nincs hozzárendelve érték. Ha értékeket rendelnek a változókhoz, az osztály objektummá válik. Az azonos osztálynak adott különböző értékek különböző objektumokat eredményeznek; vagyis a különböző objektumok ugyanaz az osztály, különböző értékekkel. Egy objektum osztályból való létrehozása azt jelenti, hogy az objektum példányosítása.
A név, sor, egy osztály. A sorosztályból létrehozott objektum programozó által választott névvel rendelkezik.
Egy osztályhoz tartozó függvényre van szükség az objektum osztályból való példányosításához. C ++ - ban ez a függvény ugyanazzal a névvel rendelkezik, mint az osztály neve. Az osztályból létrehozott (példányosított) objektumoknak a programozó különböző neveket adott.
Objektum létrehozása az osztályból az objektum felépítését jelenti; azonnali beavatkozást is jelent.
A sorosztályt használó C ++ program a következő sorokkal kezdődik a fájl tetején:
#befoglalni#befoglalni
névtér standard használatával;
Az első sor a bemenet/kimenet. A második sor az, hogy a program használhatja a sorosztály összes szolgáltatását. A harmadik sor lehetővé teszi a program számára, hogy a szabványos névtérben lévő neveket használja.
Egy funkció túlterhelése
Ha két vagy több különböző funkció -aláírás azonos névvel rendelkezik, akkor ez a név túlterhelt. Egy függvény meghívásakor az argumentumok száma és típusa határozza meg, hogy melyik függvény valósul meg.
Építkezés
sor<típus>név()A következő nyilatkozat pillanatnyilag egy sorot nevez, inte típusú que.
sor<int>hogy;A sor üres. A nyilatkozat a fenntartott szóval, sorral kezdődik, majd ezt követi az adattípussal rendelkező zárójelek. Ezután megadja a programozó nevét a sorhoz.
Építés inicializáló listával
A következő definíció bemutatja, hogyan hozhat létre sort az inicializáló listával:
sor<úszó>hogy({1.1, 2.2, 3.3, 4.4});Sor megsemmisítése
A sor megsemmisítéséhez egyszerűen engedje el a hatókörből.
Hozzáférés a várólistához
lökés (érték)
A várólista az első beérkezők listája. Tehát minden értéket hátulról adnak hozzá. A következő kódszegmens üres sort hoz létre, amely után öt úszó érték kerül hozzáadásra a hátulról:
sor<úszó>hogy;hogy.nyom(1.1);
hogy.nyom(2.2);
hogy.nyom(3.3);
hogy.nyom(4.4);
hogy.nyom(5.5);
size () const
Ez visszaadja a sorban lévő elemek számát. A következő kód szemlélteti:
sor<úszó>hogy;hogy.nyom(1.1);hogy.nyom(2.2);hogy.nyom(3.3);hogy.nyom(4.4);hogy.nyom(5.5);
költség<<hogy.méret() << ' n';
A kimenet 5.
elülső()
Ez egy hivatkozást ad vissza a sor első elemére az elem eltávolítása nélkül. A következő kód kimenete 1.1.
sor<úszó>hogy;hogy.nyom(1.1);hogy.nyom(2.2);hogy.nyom(3.3);hogy.nyom(4.4);hogy.nyom(5.5);
költség<<hogy.elülső() << ' n';
Az elem nincs eltávolítva a sorból.
front () const
Ha a sor felépítését a const előzi meg, akkor a front () const kifejezés kerül végrehajtásra a front () helyett. Például a következő kódban használják.
constsor<úszó>hogy({1.1, 2.2, 3.3, 4.4, 5.5});költség<<hogy.elülső() << ' n';
Az állandó hivatkozás visszatér. Az elem nincs eltávolítva a vektorból. A sor elemei nem módosíthatók.
vissza()
Ez egy hivatkozást ad vissza a sor utolsó elemére az elem eltávolítása nélkül. A következő kód kimenete 5.5.
sor<úszó>hogy;hogy.nyom(1.1);hogy.nyom(2.2);hogy.nyom(3.3);hogy.nyom(4.4);hogy.nyom(5.5);
költség<<hogy.vissza() << ' n';
vissza () const
Ha a sor építését a const előzi meg, akkor a back () const kifejezés kerül végrehajtásra a back () helyett. Például a következő kódban használják.
constsor<úszó>hogy({1.1, 2.2, 3.3, 4.4, 5.5});költség<<hogy.vissza() << ' n';
Az állandó hivatkozás visszatér. Az elem nincs eltávolítva a sorból. A sorkonstrukció előző konstjával a sor elemei nem módosíthatók.
Sorkapacitás
size () const
- lásd fent
üres () const
Ez 1 értéket ad vissza igaznak, ha nincsenek elemek a sorban, vagy 0 értéket hamisnak, ha a sor üres. A következő kód ezt szemlélteti:
sor<úszó>hogy1({1.1, 2.2, 3.3, 4.4, 5.5});költség<<hogy1.üres() << ' n';
sor<úszó>hogy2;
költség<<hogy2.üres() << ' n';
A kimenet:
01
Sor módosítók
pop ()
A sor FIFO, ezért minden eltávolítandó elemet el kell távolítani a sor tetejéről (fejéről). Ez a tagfüggvény eltávolítja az első elemet anélkül, hogy visszaadná. A következő kód ezt szemlélteti:
sor<úszó>hogy({1.1, 2.2, 3.3, 4.4, 5.5});költség<<hogy.elülső() << ' n';
hogy.pop();
költség<<hogy.méret() << ' n';
A kimenet:
1.14
a. csere (b)
Két sor cserélhető, amint ezt a kódszegmens mutatja:
sor<úszó>hogy1({1.1, 2.2, 3.3, 4.4, 5.5});sor<úszó>hogy2({10, húsz});
hogy1.csere(hogy2);
költség<< 'A que1 első eleme és mérete:
'<<hogy1.elülső() <<','<<hogy1.méret() << ' n';
költség<< 'A que2 első eleme és mérete'<<
hogy2.elülső() <<','<<hogy2.méret() << ' n';
A kimenet:
A que1: 10, 2 első eleme és mérete
A que2 első eleme és mérete: 1.1, 5
Vegye figyelembe, hogy szükség esetén a sor hossza megnő. Ezenkívül azokat az értékeket, amelyek nem tartalmaztak cserét, valamilyen alapértelmezett érték váltja fel. Az adattípusoknak azonos típusúaknak kell lenniük.
Esélyegyenlőségi és relációs operátorok a sorokhoz
A C ++ rendes karakterek esetében növekvő sorrendben a számok a nagybetűk előtt állnak, a kisbetűk előtt. A szóköz karakter nulla elé kerül, és mindegyik.
Egyenlőségi szereplők
1 -et ad vissza igaznak és 0 -t hamisnak.
A == operátor
1 -et ad vissza, ha a két sor azonos méretű, és a megfelelő elemek egyenlők; különben 0 -t ad vissza. Példa:
sor<const char*>hogy1({'kedves', 'valami más'});sor<const char*>hogy2({'gonosz'});
intaz egyiken=hogy1==hogy2;
költség<<az egyiken<< ' n';
A kimenet: 0.
A! = Kezelő
- a fentiekkel ellentétben. Példa:
sor<const char*>hogy1({'kedves', 'valami más'});sor<const char*>hogy2({'gonosz'});
intaz egyiken=hogy1! =hogy2;
költség<<az egyiken<< ' n';
A kimenet: 1.
Relációs operátorok
1 -et ad vissza igaznak és 0 -t hamisnak.
Az
Visszaadja az 1 értéket, ha az első sor a második sor kezdeti részhalmaza, ahol a két egyenlő rész elemei azonosak és ugyanabban a sorrendben vannak. Ha mindkét sor azonos méretű vagy különböző méretű, és balról jobbra haladva egy olyan elemet talál az első sorban, amely kisebb, mint a második sor megfelelő eleme, akkor az 1 továbbra is visszatér. Ellenkező esetben 0 kerül visszaadásra. Példa:
sor<const char*>hogy1({'kedves', 'valami más'});sor<const char*>hogy2({'gonosz'});
intaz egyiken=hogy1<hogy2;
költség<<az egyiken<< ' n';
A kimenet 1. A> Kezelő - a fentiekkel ellentétben. Példa: Kimenet: 0 Az<= Operator - ugyanaz, mint a Kimenet: 1 A> = Kezelő - a fentiekkel ellentétben. Példa: Kimenet: 0 Az érték egy adattípushoz tartozik, mint a példányosított objektum az osztályhoz. A sorkonstrukció egy osztályt is elfogadhat adattípusként. Az alábbi program ezt szemlélteti: A kimenet 5. A sorlistát technikailag hivatkozott listának nevezik. A sorhoz kétféle linkelt lista tartozik: külön linkelt lista és kétszer linkelt lista. Egy külön linkelt listaelem két tagból álló struktúrával valósítható meg. Az egyik tag mutatót mutat a következő elemre, a másik pedig a nullapontot (egyes számadatok). Egy kétszeresen linkelt listaelem háromtagú struktúrával valósítható meg. A középső tag tartja a nullapontot, míg az első és a harmadik tag mutatókat mutat a szomszédos elemekre. A sor egy első az elsőben adatszerkezet. Vannak olyan helyzetek a számítástechnikában, amikor az adatok sorban érkeznek, ami az első az elsőben viselkedést teszi szükségessé. A számítógép erőforrása a korlátozottan rendelkezésre álló fizikai vagy virtuális összetevő. Ezek közé tartozik a CPU, a videokártya, a merevlemez és a memória. Egy ilyen erőforrás megosztásához várólistára van szükség. A számítógépes perifériáknak időről időre meg kell szakítaniuk a számítógépet. A megszakításokat ugyanúgy kell kezelni, mint ahogy megérkeztek. Ehhez sorra van szükség. A sor használható például egy feladat alkalmazásfájljainak kezelésére, ha a fájlok a számítógépen vannak tárolva. A sor egy listaadatstruktúra, amely vagy külön linkelt lista, vagy kétszer linkelt lista. Általában az első elem, amely belép a listába, az első elem, amely kijön. A C ++ egy soros adatstruktúrát biztosít szabványos könyvtárában. Az ehhez a struktúrához elérhető tagfüggvények és operátorok kategóriái a sorépítés, a várólista -hozzáférés, a sorkapacitás, a sormódosítók és a sor túlterhelt operátorok. Minden sor adatstruktúrájának legalább a push () és a pop () tagfüggvényeket kell biztosítania. push () azt jelenti, hogy új elemet küldünk a sor hátsó részébe; és a pop () azt jelenti, hogy eltávolítjuk a sor elején lévő elemet. Sajnos a C ++ - ban ezek a függvények nem adják vissza az eltolt vagy kipattant értéket. Tehát ahhoz, hogy az utolsó elemet megtudjuk a tolás előtt, az extra back () függvényt kell használni; és az első elem megismeréséhez a popping előtt az extra front () függvényt kell használni. Az érték egy adattípushoz tartozik, mint a példányosított objektum az osztályhoz. Tehát egy adott osztály használható adattípusként a sor sablon példányosításához. Az osztály különböző objektumai olyanok lesznek, mint az osztály különböző értékei. A sorban vannak alkalmazások a számítógépen. Használható például egy feladat alkalmazásfájljainak kezelésére, ha a fájlokat a számítógép tárolja. Chrys
sor<const char*>hogy2({'gonosz'});
intaz egyiken=hogy1>hogy2;
költség<<az egyiken<< ' n';
sor<const char*>hogy2({'gonosz'});
intaz egyiken=hogy1<=hogy2;
költség<<az egyiken<< ' n';
sor<const char*>hogy2({'gonosz'});
intaz egyiken=hogy1> =hogy2;
költség<<az egyiken<< ' n'; Osztály és a hozzá tartozó objektumok
#befoglalni
névtér standard használatával;
osztály TheCla
{
nyilvános:
intaz egyiken;
statikus charch;
üresfunkció(charnem, const char *o)
{
költség<< 'Vannak ' <<az egyiken<< 'érdemes könyvek' <<nem<<o<< ' az áruházban.' << ' n';
}
statikus üresszórakoztató(charch)
{
ha (ch== 'nak nek')
költség<< „Hivatalos statikus tagfunkció” << ' n';
}
};
intfő-()
{
TheCla obj1;TheCla obj2;TheCla obj3;TheCla obj4;TheCla obj5;
sor<TheCla>hogy;
hogy.nyom(obj1);hogy.nyom(obj2);hogy.nyom(obj3);hogy.nyom(obj4);hogy.nyom(obj5);
költség<<hogy.méret() << ' n';
Visszatérés 0;
} Linkelt lista
A várólista alkalmazásai
Számítógépes erőforrások megosztása
Megszakítások kezelése
Információk kezelése.
Következtetés