Panimula
Ang pila ay isang koleksyon ng mga item, kung saan ang unang item na naidagdag sa listahan, ay dapat na ang unang item na natanggal sa susunod. Kaya't habang idinagdag ang mga item sa koleksyon, lumalaki ito sa laki, ibig sabihin, lumalaki ito sa haba. Kailan man ang anumang item ay aalisin, dapat itong ang unang idinagdag. Kung ang mga item ay tinanggal nang tuloy-tuloy, pagkatapos ang susunod na tinanggal, ay ang pangalawang item; ang pangatlo ay tinanggal pagkatapos, at iba pa.
Matapos maalis ang unang item ng orihinal na listahan, ang pangalawa ay magiging unang item. Matapos maalis ang pangalawang item, ang pangatlo ay magiging unang item, at iba pa.
Ang isang magandang halimbawa ng tunay na buhay ng isang pila ay kapag pumila ang mga tao upang maghintay para sa serbisyo o mabuti. Ang unang tao ay pinaglilingkuran muna bago ang huli. Gayunpaman, pinag-uusapan ng pila sa tutorial na ito, ang pila ng software, tulad ng idinisenyo sa C ++.
FIFO
Ang FIFO ay nangangahulugang First-In, First-Out. Ito ay isa pang paraan ng pagpapahalaga sa pila. Nangangahulugan ito, ang unang item na ipinasok ang listahan, ay ang unang item na aalisin, tuwing magaganap ang pagtanggal. Ang simula ng listahan ay tinatawag na ulo o harap; ang dulo ng listahan ay tinatawag na likod o buntot.
Mahalagang Operasyon
Ang isang pila ng software ay dapat magkaroon ng hindi bababa sa mga sumusunod na pagpapatakbo:
itulak
Ang operasyon na ito, ay nagdaragdag ng isang bagong elemento sa likod ng pila. Opisyal na tinawag ang operasyong ito, enqueue.
paglilipat
Inaalis ng operasyong ito ang unang elemento ng pila, at ang pangalawang elemento ay nagiging bagong unang elemento. Opisyal na tinawag na dequeue ang operasyong ito. Tinatawag itong pop sa C ++.
Ipinapaliwanag ng artikulong ito kung paano gamitin ang istraktura ng data ng pila ng C ++. Dapat mong malaman ang mga panuto ng C ++ at sanggunian upang maunawaan ang natitirang artikulong ito.
Klase at Mga Bagay
Ang isang klase ay isang hanay ng mga variable at pagpapaandar na gumagana nang magkasama, kung saan ang mga variable ay walang mga itinalagang halaga. Kapag ang mga halaga ay itinalaga sa mga variable, ang klase ay magiging isang object. Ang iba't ibang mga halagang binigyan ng parehong klase ay nagreresulta sa iba't ibang mga bagay; iyon ay, iba't ibang mga bagay ay ang parehong klase na may iba't ibang mga halaga. Ang paglikha ng isang bagay mula sa isang klase ay sinasabing nagpapatibay ng bagay.
Ang pangalan, pila, ay isang klase. Ang isang bagay na nilikha mula sa klase ng pila ay may napiling programmer na pangalan.
Ang isang pagpapaandar na kabilang sa isang klase ay kinakailangan upang masimulan ang isang bagay mula sa klase. Sa C ++, ang pagpapaandar na iyon ay may parehong pangalan sa pangalan ng klase. Ang mga bagay na nilikha (instantiated) mula sa klase ay may iba't ibang mga pangalan na ibinigay sa kanila, ng programmer.
Ang paglikha ng isang bagay mula sa klase ay nangangahulugang pagbuo ng object; nangangahulugan din ito ng pag-uudyok.
Ang isang C ++ na programa na gumagamit ng klase ng pila, nagsisimula sa mga sumusunod na linya sa tuktok ng file:
# isama# isama
gamit ang namespace std;
Ang unang linya ay para sa input / output. Ang pangalawang linya ay upang payagan ang programa na gamitin ang lahat ng mga tampok ng klase ng pila. Pinapayagan ng pangatlong linya ang programa na gamitin ang mga pangalan sa karaniwang namespace.
Pag-overload ng isang Pag-andar
Kapag ang dalawa o higit pang magkakaibang mga lagda ng pag-andar ay may parehong pangalan, ang pangalan na iyon ay sinasabing sobra ang karga. Kapag ang isang pagpapaandar ay tinawag, ang bilang at uri ng mga argumento, alamin kung aling pagpapaandar ang talagang naisakatuparan.
Konstruksyon
pila<uri>pangalan()Ang sumusunod na deklarasyon ay nagsisimula sa isang pila na pinangalanang, que of type int.
pila<int>yan;Walang laman ang pila. Ang deklarasyon ay nagsisimula sa nakalaang salita, pila na sinusundan ng mga anggulo na bracket na may uri ng data. Pagkatapos ay mayroon kang programmer na binigyan ng pangalan para sa pila.
Bumubuo sa Listahan ng Initializer
Ipinapakita ng sumusunod na kahulugan kung paano lumikha ng isang pila na may listahan ng initializer:
pila<lumutang>yan({1.1, 2.2, 3.3, 4.4});Pagsira sa isang pila
Upang sirain ang isang pila, hayaan mo lang itong lumabas sa saklaw.
Pag-access ng Element ng Queue
itulak (halaga)
Ang pila ay isang listahan ng First-In-First-Out. Kaya, ang bawat halaga ay idinagdag mula sa likuran. Ang sumusunod na segment ng code ay lumilikha ng isang walang laman na pila, at pagkatapos ay idinagdag ang limang mga halaga ng float mula sa likuran:
pila<lumutang>yan;yanitulak(1.1);
yanitulak(2.2);
yanitulak(3.3);
yanitulak(4.4);
yanitulak(5.5);
laki () const
Ibinabalik nito ang bilang ng mga elemento sa pila. Ang sumusunod na code ay naglalarawan:
pila<lumutang>yan;yanitulak(1.1);yanitulak(2.2);yanitulak(3.3);yanitulak(4.4);yanitulak(5.5);
gastos<<yanlaki() << ' n';
Ang output ay 5.
harap ()
Nagbabalik ito ng isang sanggunian sa unang elemento ng pila, nang hindi inaalis ang elemento. Ang output ng sumusunod na code ay 1.1.
pila<lumutang>yan;yanitulak(1.1);yanitulak(2.2);yanitulak(3.3);yanitulak(4.4);yanitulak(5.5);
gastos<<yansa harap() << ' n';
Ang sangkap ay hindi tinanggal mula sa pila.
harap () const
Kapag ang konstruksyon ng pila ay naunahan ng const, ang expression na front () const ay naisagawa sa halip na harap (). Ginagamit ito sa sumusunod na code, halimbawa.
Constpila<lumutang>yan({1.1, 2.2, 3.3, 4.4, 5.5});gastos<<yansa harap() << ' n';
Ang isang pare-pareho na sanggunian ay naibalik. Ang sangkap ay hindi tinanggal mula sa vector. Hindi mababago ang mga elemento ng pila.
likod ()
Nagbabalik ito ng isang sanggunian sa huling elemento ng pila, nang hindi inaalis ang elemento. Ang output ng sumusunod na code ay 5.5.
pila<lumutang>yan;yanitulak(1.1);yanitulak(2.2);yanitulak(3.3);yanitulak(4.4);yanitulak(5.5);
gastos<<yanbumalik() << ' n';
likod () const
Kapag ang pagpapatayo ng pila ay naunahan ng const, ang expression na pabalik () const ay naisakatuparan sa halip na pabalik (). Ginagamit ito sa sumusunod na code, halimbawa.
Constpila<lumutang>yan({1.1, 2.2, 3.3, 4.4, 5.5});gastos<<yanbumalik() << ' n';
Ang isang pare-pareho na sanggunian ay naibalik. Ang sangkap ay hindi tinanggal mula sa pila. Sa naunang const para sa konstruksyon ng pila, ang mga elemento sa pila ay hindi mababago.
Kapasidad ng pila
laki () const
- tingnan sa itaas
walang laman () const
Ibinabalik nito ang 1 para sa totoo kung walang mga elemento sa pila, o 0 para sa hindi totoo kung ang pila ay walang laman. Ang sumusunod na code ay naglalarawan nito:
pila<lumutang>iyon1({1.1, 2.2, 3.3, 4.4, 5.5});gastos<<iyon1.walang laman() << ' n';
pila<lumutang>yan2;
gastos<<yan2.walang laman() << ' n';
Ang output ay:
01
Mga Modifier ng pila
pop ()
Ang isang pila ay FIFO, kaya ang anumang elemento na kailangang alisin ay dapat na alisin mula sa itaas (ulo) ng pila. Tinatanggal ng pagpapaandar ng miyembro na ito ang unang elemento nang hindi ito ibabalik. Ang sumusunod na code ay naglalarawan nito:
pila<lumutang>yan({1.1, 2.2, 3.3, 4.4, 5.5});gastos<<yansa harap() << ' n';
yanpop();
gastos<<yanlaki() << ' n';
Ang output ay:
1.14
a. palitan (b)
Maaaring mapalitan ang dalawang pila, tulad ng inilalarawan sa segment ng code na ito:
pila<lumutang>iyon1({1.1, 2.2, 3.3, 4.4, 5.5});pila<lumutang>yan2({10, dalawampu});
iyon1.magpalit(yan2);
gastos<< 'Unang elemento at sukat ng que1:
'<<iyon1.sa harap() <<','<<iyon1.laki() << ' n';
gastos<< 'Unang elemento at sukat ng que2'<<
yan2.sa harap() <<','<<yan2.laki() << ' n';
Ang output ay:
Unang elemento at sukat ng que1: 10, 2
Unang elemento at sukat ng que2: 1.1, 5
Tandaan na ang haba ng isang pila ay nadagdagan kung kinakailangan. Gayundin, ang mga halagang walang mga kapalit, ay pinalitan ng ilang default na halaga. Ang mga uri ng data ay dapat na magkatulad na uri.
Pagkapantay-pantay at Mga Kaugnay na Operator para sa Mga Queue
Para sa mga ordinaryong character sa C ++, sa pataas na pagkakasunud-sunod, ang mga numero ay nauna sa mga malalaking titik, na dating bago ang mga maliliit na titik. Ang character space ay nauna bago ang zero at lahat ng mga ito.
Mga Operator ng Equality
Ibinabalik ang 1 para sa totoo at 0 para sa hindi totoo.
Ang == Operator
Ibinabalik ang 1 kung ang dalawang pila ay may parehong sukat at ang mga kaukulang elemento ay pantay; kung hindi man ay nagbabalik ito 0. Halimbawa:
pila<Const char*>iyon1({'mabait', 'iba pa'});pila<Const char*>yan2({'masama'});
intsa isa=iyon1==yan2;
gastos<<sa isa<< ' n';
Ang output ay: 0.
Ang! = Operator
- kabaligtaran ng nasa itaas. Halimbawa:
pila<Const char*>iyon1({'mabait', 'iba pa'});pila<Const char*>yan2({'masama'});
intsa isa=iyon1! =yan2;
gastos<<sa isa<< ' n';
Ang output ay: 1.
Mga kaugnay na Operator
Ibinabalik ang 1 para sa totoo at 0 para sa hindi totoo.
Ang
Ibinabalik ang 1 kung ang unang pila ay ang paunang subset ng pangalawang pila, na may mga elemento ng dalawang pantay na bahagi na pareho at nasa parehong pagkakasunud-sunod. Kung ang parehong mga pila ay pareho ang laki o magkakaibang laki, at paglipat mula kaliwa patungo sa kanan, ang isang elemento ay nakatagpo sa unang pila na mas mababa kaysa sa kaukulang elemento sa pangalawang pila, pagkatapos ay ibabalik pa rin ang 1. Kung hindi man ay ibabalik ang 0. Halimbawa:
pila<Const char*>iyon1({'mabait', 'iba pa'});pila<Const char*>yan2({'masama'});
intsa isa=iyon1<yan2;
gastos<<sa isa<< ' n';
Ang output ay 1. Ang> Operator - kabaligtaran ng nasa itaas. Halimbawa: Output: 0 Ang<= Operator - katulad ng Output: 1 Ang> = Operator - kabaligtaran ng nasa itaas. Halimbawa: Output: 0 Ang isang halaga ay sa isang uri ng data, bilang isang instantiated object ay sa isang klase. Ang pagtayo ng pila ay maaari ring tanggapin ang isang klase bilang isang uri ng data. Inilalarawan ito ng sumusunod na programa: Ang output ay 5. Ang listahan ng pila ay teknikal na tinatawag na isang naka-link na listahan. Mayroong dalawang uri ng mga naka-link na listahan para sa pila: iisa ang naka-link na listahan at doble na naka-link na listahan. Ang isang elemento ng listahan ng naiisa na naka-link ay maaaring ipatupad ng isang istraktura ng dalawang miyembro. Ang isang miyembro ay nagtataglay ng isang pointer sa susunod na elemento at ang iba pang miyembro ay nagtataglay ng datum (isahan para sa data). Ang isang doble na naka-link na elemento ng listahan ay maaaring ipatupad ng isang istraktura ng tatlong mga miyembro. Hawak ng gitnang miyembro ang datum, habang ang una at pangatlong miyembro ay nagtataglay ng mga payo sa kanilang mga katabing elemento. Ang pila ay isang first-in-first-out na istraktura ng data. Mayroong mga sitwasyon sa pag-compute kapag dumating ang data sa anyo ng isang pila, na nangangailangan ng pag-uugali ng first-in-first-out. Ang isang mapagkukunan sa isang computer ay anumang pisikal o virtual na sangkap ng limitadong kakayahang magamit. Kasama nila ang CPU, video card, hard drive, at memorya. Ang pagbabahagi ng naturang mapagkukunan ay nangangailangan ng isang pila. Kailangang magambala ng mga computer peripheral ang computer paminsan-minsan. Ang mga nakakagambala ay kailangang hawakan sa parehong paraan na kanilang narating. Kailangan nito ng pila. Maaaring gamitin ang pila, halimbawa, upang pamahalaan ang mga file ng aplikasyon para sa isang trabaho, kung ang mga file ay nakaimbak sa computer. Ang isang pila ay isang istraktura ng data ng listahan, na alinman sa isang listahan na nag-iisa na naka-link o isang listahan na doble-link. Bilang isang patakaran, ang unang elemento na pumasok sa listahan ay ang unang sangkap na lumabas. Nagbibigay ang C ++ ng istraktura ng data ng pila sa pamantayang aklatan nito. Ang mga kategorya ng mga pagpapaandar ng miyembro at mga operator na magagamit para sa istrakturang ito ay konstruksyon ng pila, pag-access ng elemento ng pila, kapasidad ng pila, mga modifier ng pila, at mga operator ng labis na karga ng pila. Ang anumang istraktura ng data ng pila ay dapat magbigay ng hindi bababa sa, ang push () at pop () na pagpapaandar ng miyembro. ang push () ay nangangahulugang, pagpapadala ng isang bagong elemento sa likod ng pila; at ang pop () ay nangangahulugang, inaalis ang elemento na nasa harap ng pila. Sa kasamaang palad, sa C ++, ang mga pagpapaandar na ito ay hindi ibabalik ang halagang itinulak o na-pop. Kaya, upang malaman ang huling elemento bago itulak, ang sobrang pag-andar ng pabalik () ay kailangang gamitin; at upang malaman ang unang elemento bago mag-pop, kailangang gamitin ang labis na pagpapaandar sa harap (). Ang isang halaga ay sa isang uri ng data, bilang isang instantiated object ay sa isang klase. Kaya, ang isang partikular na klase ay maaaring magamit bilang isang uri ng data para sa pagsisimula ng template ng pila. Ang iba't ibang mga bagay para sa klase ay naging tulad ng iba't ibang mga halaga para sa klase. Ang pila ay may mga application sa computer. Maaari itong magamit, halimbawa, upang pamahalaan ang mga file ng aplikasyon para sa isang trabaho, kung ang mga file ay nakaimbak sa computer. Chrys
pila<Const char*>yan2({'masama'});
intsa isa=iyon1>yan2;
gastos<<sa isa<< ' n';
pila<Const char*>yan2({'masama'});
intsa isa=iyon1<=yan2;
gastos<<sa isa<< ' n';
pila<Const char*>yan2({'masama'});
intsa isa=iyon1> =yan2;
gastos<<sa isa<< ' n'; Klase at mga Instantiated na Bagay nito
# isama
gamit ang namespace std;
klase AngCla
{
pampubliko:
intsa isa;
static charch;
walang bisapagpapaandar(charhindi, Const char *p)
{
gastos<< 'Meron' <<sa isa<< 'librong nagkakahalaga' <<hindi<<p<< ' sa tindahan.' << ' n';
}
static walang bisamasaya(charch)
{
kung (ch== 'to')
gastos<< 'Opisyal na pag-andar ng static member' << ' n';
}
};
intpangunahing()
{
TheCla obj1;TheCla obj2;TheCla obj3;TheCla obj4;TheCla obj5;
pila<AngCla>yan;
yanitulak(obj1);yanitulak(obj2);yanitulak(obj3);yanitulak(obj4);yanitulak(obj5);
gastos<<yanlaki() << ' n';
bumalik ka 0;
} Listahan ng naka-link
Mga aplikasyon ng pila
Pagbabahagi ng Mga Mapagkukunan ng Computer
Paghawak ng Mga Pagkagambala
Pamahalaan ang impormasyon.
Konklusyon