Sa C++, STL (Standard Template Library), mga lalagyan ay mga bagay na ginagamit upang mag-imbak ng mga koleksyon ng iba pang mga bagay. Gumagana ang mga ito nang katulad sa mga template ng klase at sumusuporta sa isang malaking bilang ng mga uri ng elemento at nagbibigay ng mga function ng miyembro upang direktang ma-access ang kanilang mga elemento o sa pamamagitan ng mga iterator.
Mga Uri ng C++ STL Container
Sa C++, mayroong tatlong uri ng STL mga lalagyan , na nakalista sa ibaba:
1: Mga Sequential Container
Sa C++, ang mga sequential container ay nagbibigay-daan sa amin na mag-imbak ng mga item na maaaring makuha nang sunud-sunod. Ang mga ito mga lalagyan ay naka-encode bilang mga array o naka-link na listahan ng mga istruktura ng data. Ang ilang mga uri ng sunud-sunod na mga lalagyan ay ibinigay sa ibaba.
- Vector: Ito ay isang dynamic na laki ng array na naka-imbak sa memorya sa magkadikit na paraan.
- Tungkol Saan: Ito ay kumakatawan sa isang double-ended queue na sumusuporta sa mga operasyon para sa parehong pagpapasok at pagtanggal.
- Array: Ito ay isang static na array na inilalaan sa panahon ng compilation habang pinananatiling maayos ang laki nito.
- Listahan: Ito ay isang dobleng naka-link na listahan na nagsasagawa ng mabilis na pagpasok at pagtanggal ng mga elemento sa anumang lugar sa listahan.
- Listahan ng Pagpasa: Isa itong single-linked na listahan tulad ng isang listahan ngunit maaari mo lamang itong daanan sa isang direksyon.
Halimbawa
Sa halimbawang ito, gagamitin natin ang klase ng vector upang ipakita kung paano a sunud-sunod lalagyan nagpapatakbo.
#include
#include
gamit ang namespace std;
int pangunahing ( ) {
// magpasimula ng isang vector ng int uri
vector < int > mga numero = { 10 , 2 , 16 , 70 , 5 } ;
// i-print ang vector
cout << 'Ang mga numero ay:' ;
para sa ( sasakyan at ako: mga numero )
{
cout << i << ',' ;
}
bumalik 0 ;
}
Ang code sa itaas ay nagpapakita ng paggamit ng sunud-sunod mga lalagyan sa vector format, na nagbibigay-daan para sa pag-imbak ng mga integer array. Ang programa ay nagpapasimula ng isang vector ng uri ng integer, nagtatalaga ng mga halaga dito, at nagpi-print ng mga ito gamit ang isang loop. Ipinapakita ng halimbawang ito kung gaano kadali ang pag-imbak at pag-access ng data sa C++ gamit ang sunud-sunod na lalagyan .
2: Mga Nag-uugnay na Lalagyan
Ang mga nag-uugnay na lalagyan payagan kaming mag-imbak ng mga elemento sa partikular na pagkakasunud-sunod na tinukoy ng operator ng paghahambing. Unlike sunud-sunod na mga lalagyan , ang pagkakasunud-sunod ng mga elemento sa nag-uugnay na mga lalagyan ay pinapanatili gamit ang mga key na nagbibigay-daan sa mga user na ayusin at i-access ang mga elemento. Kapag ang isang elemento ay ipinasok sa isang nag-uugnay na lalagyan , awtomatiko itong pinagbubukod-bukod sa tamang posisyon batay sa susi nito. Ang mga uri ng container na ito ay ipinapatupad sa loob tulad ng mga istruktura ng data ng binary tree.
Ang nag-uugnay mga lalagyan ay ikinategorya bilang:
- Mapa: isang koleksyon ng mga pares ng key-value na pinagsunod-sunod gamit ang mga natatanging key
- Multimap: isang koleksyon ng mga pares ng key-value na pinagsunod-sunod gamit ang mga key
- Itakda: Mga natatanging susi na kinokolekta at inayos ayon sa mga susi.
- Multiset: isang koleksyon ng mga susi na pinagsunod-sunod gamit ang mga susi
Halimbawa
Upang ilarawan kung paano ang isang nag-uugnay lalagyan gumagana, gagamitin namin ang itakda ang klase sa halimbawang ito.
#include#include
gamit ang namespace std;
int pangunahing ( )
{
// magpasimula a itakda ng int uri
itakda < int > mga numero = { 10 , 2 , 16 , 70 , 5 } ;
// i-print ang itakda
cout << 'Ang mga numero ay:' ;
para sa ( sasakyan at ako: mga numero )
{
cout << i << ',' ;
}
bumalik 0 ;
}
Ang code sa itaas ay nagpapasimula ng isang hanay ng mga integer sa C++, na isang halimbawa ng isang nag-uugnay na lalagyan. Tinitiyak ng set na ang mga elemento ay pinagsunod-sunod sa pataas na pagkakasunud-sunod bilang default. Pagkatapos ay ipi-print ng code ang mga numero sa set gamit ang for loop.
3: Hindi Naayos na Mga Kaugnay na Lalagyan
Sa C++, unordered associative mga lalagyan ay ginagamit para sa pagbibigay ng hindi pinagsunod-sunod na mga bersyon ng isang nag-uugnay lalagyan . Ang mga ito ay panloob na ipinatupad tulad ng hash table data structures. Ang nag-uugnay mga lalagyan ay ikinategorya bilang:
- Hindi Nakaayos na Mapa: isang koleksyon ng mga pares ng key-value na na-hash gamit ang mga natatanging key.
- Hindi Naayos na Multimap: ang koleksyon ng key-value pairs na na-hash gamit ang mga key.
- Unordered Set: isang koleksyon ng mga natatanging key na na-hash gamit ang mga key.
- Hindi Nakaayos na Multiset: isang koleksyon ng mga susi na na-hash gamit ang mga susi.
Halimbawa
Upang mailarawan kung paano ang isang unordered associative lalagyan gumagana, gagamitin namin ang unordered set klase sa halimbawang ito.
#include#include
gamit ang namespace std;
int pangunahing ( )
{
// magpasimula ng unordered_set ng int uri
unordered_set < int > mga numero = { 10 , 2 , 16 , 70 , 5 } ;
// i-print ang itakda
cout << 'Ang mga numero ay:' ;
para sa ( sasakyan at ako: mga numero )
{
cout << i << ',' ;
}
bumalik 0 ;
}
Konklusyon
Isang STL C++ lalagyan ay ang may hawak na bagay upang mag-imbak ng koleksyon ng iba pang mga bagay. Gumagana ang mga ito nang katulad sa mga template ng klase at sumusuporta sa isang malaking bilang ng mga uri ng elemento. Sa tutorial na ito, tinalakay namin ang pinakakaraniwang ginagamit na mga uri ng mga lalagyan ng STL C++, na sunud-sunod na mga lalagyan, mga nag-uugnay na lalagyan pati na rin ang hindi nakaayos na mga kaugnay na lalagyan .