30 Példák a C++ vektorokra

A C++-ban a Vector egydimenziós adatstruktúra, amely dinamikusan növekszik a követelmény alapján. Az adatszervezés (beillesztés/módosítás/törlés) hatékonyan végezhető ebben az adatstruktúrában. Alkalmazásai a következők:

1. A matematikai vektorok ábrázolása tudományos és mérnöki alkalmazásokban
2. Sorok, veremek implementálhatók ezzel az adatstruktúrával stb.

Az ehhez az adatstruktúrához kapcsolódó általános CRUD-műveletek és funkciók többségét forgatókönyv szerint részletesen, szintaxissal és kódrészletekkel tárgyaljuk.

Tartalom témája:

1. Elem beszúrása vektorba
2. Szúrjon be több elemet egy vektorba
3. Hozzáférés az elemekhez vektorból
4. Frissítse az elemet vektorban
5. Egy adott elem eltávolítása a vektorból
6. Távolítsa el az összes elemet a vektorból
7. Vektorok Uniója
8. Vektorok metszéspontja
9. Ellenőrizze, hogy a vektor üres-e vagy sem
10. Haladjon be egy vektort a Const_Iterator segítségével
11. Bejárás egy vektoron a Reverse_Iterator segítségével
12. Tolja be az elemeket a vektorba
13. Pop az elemeket a vektorból
14. Cserélje ki a vektorokat
15. Hozza ki az első elemet a vektorból
16. Hozza ki az utolsó elemet a vektorból
17. Rendeljen új értékeket egy vektorhoz
18. A vektor kiterjesztése az Emplace() segítségével
19. A vektor kiterjesztése az Emplace_Back() használatával
20. Egy vektor maximális eleme
21. A vektor minimális eleme
22. Elemek összege egy vektorban
23. Két vektor elemi alapú szorzása
24. Két vektor pontszorzata
25. Alakítsa át a halmazt vektorrá
26. Távolítsa el az ismétlődő elemeket
27. Alakítson át egy vektort halmazzá
28. Távolítsa el az üres karakterláncokat
29. Írjon vektort egy szövegfájlba
30. Vektor létrehozása szöveges fájlból

Elem beszúrása vektorba

A std::vector::insert() függvény a C++ STL-ben az elemek beillesztésére szolgál a megadott helyre.

Szintaxis:

Használjuk ezt a funkciót, és adjuk át az első pozíciót paraméterként, amely meghatározza azt a helyet, ahová az elemet be kell illeszteni, és adjuk meg az elemet második paraméterként.

A begin() függvény itt használható egy olyan iterátor visszaadására, amely a bemeneti vektor első elemére mutat. Ha ehhez a funkcióhoz hozzáadja a pozíciót, az elem beszúrásra kerül az adott pozícióba.

Hozzuk létre a string típusú „student_names” vektort, és szúrjunk be két karakterláncot az első és a második pozícióba, egymás után az insert() függvény segítségével.

Kimenet:

Korábban a „student_names” vektor üres volt. A beillesztés után a vektor két elemet tartalmaz.

Szúrjon be több elemet egy vektorba

Ebben a forgatókönyvben ugyanazt a függvényt használjuk, mint az std::vector::insert(). De át kell adnunk az extra/különböző paramétereket ugyanannak a függvénynek, hogy több elemet beszúrhassunk egy vektorba.

1. forgatókönyv: Egyetlen elem többszöri beszúrása

Ebben a forgatókönyvben ugyanazt az elemet többször adjuk hozzá.

Szintaxis:

Ehhez második paraméterként a méretet kell átadnunk az insert() függvénynek. A függvénynek átadott összes paraméter három.

Itt:

1. A pozíció paraméter határozza meg a beszúrandó elem pozícióját. Ha a méret nagyobb, mint 1, akkor a kiindulási pozíció indexe a pozíció lesz.
2. A méret paraméter határozza meg, hányszor kell egy elemet beilleszteni.
3. Az elem paraméter a beszúrandó elemet egy vektorba veszi.

Tekintsük a „diák_nevek” vektort két karakterlánccal. Szúrja be a „Lavanya” húrokat ötször a második pozícióba.

Kimenet:

A meglévő vektorban a „Sravan Kumar” az első helyen, a „Lalitha” pedig a második helyen áll. A „Lavanya” ötszöri beszúrása után (a második pozícióból a hatodik pozícióba), „Lalitha” a hetedik pozícióba (utolsó) lépett.

2. forgatókönyv: Több elem beszúrása

Ebben a forgatókönyvben egyszerre adjuk hozzá a különböző elemeket egy másik vektorból. Itt is ugyanazt a függvényt használjuk, de a szintaxis és a paraméterek megváltoznak.

Szintaxis:

Ehhez második paraméterként a méretet kell átadnunk az insert() függvénynek. A függvénynek átadott összes paraméter három.

Itt:

1. A pozíció paraméter határozza meg a beszúrandó elem pozícióját.
2. A „first_iterator” meghatározza azt a kiindulási pozíciót, ahonnan az elemeket be kell illeszteni (alapvetően a begin() függvény használatával egy iterátort ad vissza, amely a tárolóban lévő első elemre mutat).
3. A „second_iterator” meghatározza azt a végpontot, ameddig az elemeket be kell illeszteni (alapvetően az end() függvény használatával egy iterátort ad vissza, amely a tároló utolsó pontja mellé mutat).

Hozzon létre két egész típusú vektort, „marks1” és „marks2” (jelek2). Illessze be a „marks2” vektorban található összes elemet a „marks1” vektor első helyére.

Kimenet:

Az első vektor (marks1) öt, a második vektor (marks2) három elemet tartalmaz. A begin (marks1), begin (marks2), end (marks2) paramétereket átadtuk az „insert” függvénynek úgy, hogy a második vektorban lévő összes elemet iteráljuk, és az elején beszúrjuk az első vektorba. Tehát az első vektor nyolc elemet tartalmaz.

Hozzáférés az elemekhez vektorból

1. A [] kezelő használatával

Egyes forgatókönyvekben előfordulhat, hogy csak az adott elemeket kell visszaadnia a vektorból. Az összes elem visszaküldése nem szükséges. Tehát ahhoz, hogy az index alapján csak az adott elemeket adja vissza, az index operátort és az at() függvényeket használja.

Szintaxis:

C++ nyelven az indexelés 0-tól kezdődik bármilyen adatszerkezet esetén. Ha az elem nem létezik, akkor üresen tér vissza (nincs hiba vagy figyelmeztetés jelenik meg).

Tekintsük az öt elemből álló „termékek” vektort. Az indexpozíció használatával egyenként érheti el az összes elemet.

Kimenet:

A 8-as indexben nincs jelen elem. Tehát üresen tér vissza.

2. Az At() függvény használata

Az At() egy tagfüggvény, amely hasonló az előző használati esethez, de az „std::out_of_range” kivételt adja vissza, ha a tartományon kívüli indexet adják meg számára.

Szintaxis:

Az indexpozíciót át kell adnunk ennek a függvénynek.

Tekintsük az öt elemből álló „termékek” vektort. Az indexpozíció segítségével egyenként érje el az összes elemet, és próbálja meg elérni a 9. pozícióban lévő elemet.

Kimenet:

Hiba történik a 9. elem elérésekor:

Elem frissítése vektorban

1. A [] kezelő használatával

Az indexpozíció segítségével frissíthetjük az elemet a vektorban. A [] operátor a frissítendő elem indexpozícióját veszi fel. Az új elem ehhez az operátorhoz lesz hozzárendelve.

Szintaxis:

Tekintsük a „student_marks” vektort öt értékkel. Frissítse az 1. és 3. indexben szereplő elemeket.

Kimenet:

Láthatjuk, hogy a végső vektor az 1-es és 3-as indexnél tartalmazza a frissítési elemeket.

2. Az At() függvény használata

Az index operátorhoz hasonlóan az at() alapvetően egy tagfüggvény, amely az iterátorban lévő index alapján frissíti az értéket. Ha a függvényen belül megadott index nem létezik, akkor a rendszer az „std::out_of_range” kivételt dobja ki.

Tekintsük az öt elemből álló „termékek” vektort. Frissítse a vektorban lévő összes elemet más elemekkel.

Kimenet:

Egy adott elem eltávolítása a vektorból

C++ nyelven a std::vector::erase() A függvény egy adott elem/elemtartomány eltávolítására szolgál egy vektorból. Az elemek eltávolítása az iterátor pozíciói alapján történik.

Szintaxis:

Lássuk az adott elem vektorból való eltávolításának szintaxisát. Használhatjuk a begin() vagy end() függvényeket, hogy meghatározzuk az eltávolítandó vektorban lévő elem pozícióját.

Tekintsük az öt elemből álló „termékek” vektort.

1. Távolítsa el a harmadik elemet a begin() iterátor megadásával. A Begin() a vektor első elemére mutat. Ha ehhez a függvényhez kettőt adunk, akkor a harmadik elemre mutat.
2. Távolítsa el az utolsó elemet az end() iterátor megadásával. Az End() a vektor utolsó elemére mutat.

Kimenet:

Most már csak három elem („szappan”, „sampon”, „gyümölcs”) létezik a „termékek” vektorban.

Távolítsa el az összes elemet a vektorból

1. forgatókönyv: Elemek egy tartományának eltávolítása egy vektorból

Használjuk az std::vector::erase() függvényt egy tartomány több elemének eltávolítására.

Szintaxis:

A két iterátor (begin() mutat az első elemre és end() pont az utolsó elem függvényei) a tartomány megadására szolgál.

Tekintsük az öt elemből álló „termékek” vektort, és távolítsuk el az összes elemet a második pozícióból. Ennek eléréséhez az első iterátor a begin (products)+1, amely a második elemre mutat, a második iterátor pedig az end (products).

Kimenet:

Most már csak egy elem („szappan”) van jelen a „termékek” vektorban.

2. forgatókönyv: Távolítsa el az összes elemet a vektorból

Használjuk a std::vector::clear() függvény az összes elem eltávolításához a vektorból.

Szintaxis:

Ennek a függvénynek nem adnak át paramétereket.

Tekintsük ugyanazt a vektort, amelyet az első forgatókönyvben használtunk, és távolítsuk el az összes elemet a clear() függvénnyel.

Kimenet:

Láthatjuk, hogy a „termékek” vektorban nincsenek elemek.

Vektorok Uniója

Lehetőség van az UNION művelet végrehajtására vektorokon az std::set_union() függvény használatával. Az Unió az ismétlődő elemek figyelmen kívül hagyásával adja vissza az egyedi elemeket a vektorokból. Mindkét iterátort át kell adnunk ennek a függvénynek. Ezzel együtt egy kimeneti iterátort kell átadni, amely tárolja a mindkét iterátor által visszaadott eredményt.

Szintaxis:

Itt:

1. A „first1” az első iterátor (vektor) első elemére mutat.
2. Az „last1” az első iterátor (vektor) utolsó elemére mutat.
3. Az „első2” a második iterátor (vektor) első elemére mutat.
4. Az „last2” a második iterátor (vektor) utolsó elemére mutat.

Hozzon létre két egész típusú vektort – „subjects1” és „subjects2” (tárgyak2).

1. Rendezze a két vektort a sort() függvény segítségével az iterátorok átadásával.
2. Hozzon létre egy kimeneti vektort (iterátort).
3. Keresse meg e két vektor unióját az std::set_union() függvény segítségével. Használja a begin()-ot első iterátorként és az end()-et utolsó iterátorként.
4. Iterálja a kimeneti vektort a függvény által visszaadott elemek megjelenítéséhez.

Kimenet:

Mind a két vektorban csak öt egyedi elem található (alany1 és alany2).

Vektorok metszéspontja

Két vektor metszéspontjának megtalálása lehetséges az std::set_intersection() függvénnyel. Az Intersection visszaadja azokat az elemeket, amelyek mindkét vektorban jelen vannak.

Szintaxis:

A set_union() függvénynek átadott paraméterek átadhatók ennek a set_intersection() függvénynek is.

Hozzon létre két egész típusú vektort – „subjects1” és „subjects2” (tárgyak2).

1. Rendezze a két vektort a sort() függvény segítségével az iterátorok átadásával.
2. Hozzon létre egy kimeneti vektort (iterátort).
3. Keresse meg a két vektor metszéspontját az std::set_intersection() függvény segítségével. Használja a begin()-ot első iterátorként és az end()-et utolsó iterátorként.
4. Iterálja a kimeneti vektort a függvény által visszaadott elemek megjelenítéséhez.

Kimenet:

Csak három elem van jelen mindkét vektorban (alanyi1 és alany2).

Ellenőrizze, hogy a vektor üres-e vagy sem

A vektorokkal való munka előtt fontos ellenőrizni, hogy a vektor üres-e vagy sem. Szintén bevált gyakorlat a szoftverprojektekben, hogy ellenőrizze, hogy a vektor üres-e vagy sem, mielőtt végrehajtana olyan műveleteket, mint a CRUD műveletek stb.

1. A Std::vector::empty()

Ez a függvény 1-et ad vissza, ha a vektor üres (nem tartalmaz elemet). Ellenkező esetben 0 kerül visszaadásra. Ennek a függvénynek nem ad át paramétert.

2. A Std::vector::size()

Az std::vector::size() függvény azt az egész számot adja vissza, amely a vektorban található elemek teljes számát reprezentálja.

Hozzon létre két vektort – „főiskola1” és „főiskola2”. A „College1” öt elemet tartalmaz, a „college2” pedig üres. Alkalmazza mindkét függvényt mindkét vektorra, és ellenőrizze a kimenetet.

Kimenet:

Az üres() függvény 0-t ad vissza a „kollégium1”-hez és 1-et a „kollégium2”-hez. A size() függvény ötöt ad vissza a „kollégium1”-hez és 0-t a „kollégium2”-hez.

Haladjon be egy vektort a Const_Iterator segítségével

Amikor C++-konténereken, például halmazokon, vektorokon stb. dolgozik, a tárolóban lévő összes elemet módosíthatja anélkül, hogy módosítaná őket. A const_iterator az egyik iterátor, amely eléri ezt a forgatókönyvet. A cbegin() (a vektor első elemére mutat) és a cend() (a vektor utolsó elemére mutat) az egyes tárolók által biztosított két függvény, amely a konstans iterátor visszaállítására szolgál a vektor elejére és végére. a tartályt. A vektor iterációja során ezt a két függvényt használhatjuk.

1. Hozzunk létre egy „részlegek” nevű vektort öt karakterlánccal.
2. Deklaráljon egy const_iterator – típusú ctr-t.
3. Iteráljon a részlegek között az előző iterátorral a „for” ciklus használatával, és jelenítse meg.

Kimenet:

Vektor bejárása a Reverse_Iterator segítségével

A fordított_iterátor szintén egy iterátor, amely hasonló a const_iteratorhoz, de az elemeket fordítottan adja vissza. Az rbegin() (a vektor utolsó elemére mutat) és a rend() (a vektor első elemére mutat) az egyes tárolók által biztosított két függvény, amely a konstans iterátor visszaállítására szolgál a végére és elejére. a tartályt.

1. Hozzunk létre egy „osztályok” nevű vektort öt karakterlánccal.
2. Deklaráljon egy reverse_iterator – típusú rtr-t.
3. Iteráljon a részlegek között az előző iterátorral a „for” ciklus használatával, és jelenítse meg.

Kimenet:

Tolja be az elemeket a vektorba

Az elemek vektorba tolása vagy hozzáfűzése egy egyirányú beszúrás, amelyet a vektor::push_back() funkció.

Szintaxis:

A vektorba paraméterként be kell tolni egy elemet.

Hozzunk létre egy üres vektort „részlegek” néven öt karakterlánccal, és nyomjunk egymás után két karakterláncot a push_back() függvény segítségével.

Kimenet:

Először megnyomjuk az „Értékesítést”. Ezt követően az „IT” bekerül a vektorba. Most a „részlegek” vektor két elemet tartalmaz.

Pop az elemeket a vektorból

Ha törölni szeretné a vektorban lévő utolsó elemet, használja a vektor::pop_back() funkció a legjobb megközelítés. Törli a vektor utolsó elemét.

Szintaxis:

Ehhez a funkcióhoz nincs szükség paraméterre. A meghatározatlan viselkedést mutatja, ha az utolsó elemet egy üres vektorból próbáljuk törölni.

Hozzunk létre egy üres vektort „részlegek” néven öt karakterlánccal, és töröljük az utolsó elemet az előző függvény segítségével. Mindkét esetben jelenítse meg a vektort.

Kimenet:

A „HR” az utolsó elem, amely jelen van a „részlegek” vektorban. Tehát eltávolítjuk a vektorból, és a végső vektorban az „Értékesítés”, „IT”, „Szolgáltatás” és „Marketing” szerepel.

Cserélje ki a vektorokat

A vektor::csere() A C++ STL függvény a két vektorban jelenlévő összes elem felcserélésére szolgál.

Szintaxis:

Nem veszi figyelembe a vektorok méretét, de a vektoroknak azonos típusúaknak kell lenniük (hiba jelenik meg, ha a vektortípusok eltérőek).

Hozzunk létre két vektort – „gyümölcsöt” és „zöldséget” – karakterlánc típusúak, különböző méretűek. Cserélje fel mindegyiket, és mindkét esetben jelenítse meg a vektorokat.

Kimenet:

Korábban a „gyümölcs” vektor két, a „zöldség” vektor három elemet tartalmazott. Csere után a „gyümölcs” vektor három, a „zöldség” vektor két elemet tartalmaz.

Hozza ki az első elemet a vektorból

Bizonyos esetekben az a követelmény, hogy a vektorból csak az első elemet kell visszaadni. A vektor::front() függvény a C++ STL-ben csak az első elemet kéri le a vektorból.

Szintaxis:

Ez a funkció nem vesz át semmilyen paramétert. Ha a vektor üres, hibaüzenet jelenik meg.

Hozzunk létre két vektort – „gyümölcsöt” és „zöldséget” – karakterlánc típusú, és próbáljuk meg az első elemet a két vektortól elkülönítve lekérni.

Kimenet:

Az „alma” az első elem, amely jelen van a „gyümölcs” vektorban. Tehát visszakerült. De hibaüzenet jelenik meg, amikor megpróbáljuk lekérni az első elemet a „zöldség” vektorból, mivel az üres.

Hozza ki az utolsó elemet a vektorból

A vektor::end() függvény a C++ STL-ben csak az utolsó elemet kéri le a vektorból.

Szintaxis:

Ez a funkció nem vesz át semmilyen paramétert. Ha a vektor üres, hibaüzenet jelenik meg.

Hozzunk létre két karakterlánc típusú vektort – „gyümölcsöt” és „zöldséget”, és próbáljuk meg az utolsó elemet külön lekérni a két vektortól.

Kimenet:

A „mangó” az utolsó elem, amely jelen van a „gyümölcs” vektorban. Tehát visszakerült. De hibaüzenet jelenik meg, amikor megpróbáljuk lekérni az utolsó elemet a „zöldség” vektorból, mivel az üres.

Rendeljen új értékeket egy vektorhoz

Egyes forgatókönyvekben, ha az összes értéket frissíteni szeretné az új értékkel, vagy létrehozni szeretne egy vektort ugyanazokkal az értékekkel, a vektor::assign() függvény használata a legjobb megközelítés. Ennek a függvénynek a használatával:

1. Hozza létre a vektort az összes hasonló elemmel
2. Módosítsa a meglévő vektort ugyanazzal az elemmel

Szintaxis:

Ehhez a funkcióhoz két paraméter szükséges.

Itt:

1. A méret határozza meg a hozzárendelendő elemek számát.
2. Az érték adja meg a hozzárendelendő elemet.

Hozzunk létre egy „marks1” nevű vektort öt értékkel, és frissítsük ezt a vektort négy elemmel úgy, hogy a frissített vektor összes eleme 20 legyen.

Kimenet:

Korábban a vektor öt különböző elemet tartalmazott. Most csak négy elemet tartalmaz, és mindegyik egyenlő 20-zal.

A vektor kiterjesztése az Emplace() segítségével

Azt már tudjuk, hogy az új elemek dinamikusan beilleszthetők a vektor bármely pozíciójába. Ez a vektor::emplace() függvény használatával lehetséges. Nézzük meg gyorsan a függvény által elfogadott szintaxist és paramétereket.

Szintaxis:

Ennek a függvénynek két kötelező paramétert kell átadni.

Itt:

1. Az első paraméter a pozíciót veszi fel, így az elemet tetszőleges pozícióba beilleszthetjük. A pozíciót a begin() vagy end() iterátor függvénnyel kaphatjuk meg.
2. A második paraméter a vektorba beillesztendő elem.

Tekintsük a két elemű „kémiai” vektort.

1. Szúrja be a „mangán” szót az első helyre – kezdődik (vegyi anyagok)
2. Szúrja be a „Réz” szót az utolsó pozícióba – vége (vegyi anyagok)
3. Illessze be a „Sulphur”-t a harmadik pozícióba – start(vegyszerek)+2

Kimenet:

Most a végső vektor öt elemet tartalmaz (a következő képernyőképen látható).

A vektor kiterjesztése az Emplace_Back() használatával

Egy elemet hozzá lehet fűzni (a vektor végéhez hozzáadva), ami a következővel tehető meg vektor::emplace_back() funkció.

Szintaxis:

A vektorhoz csatolandó elemet kötelező paraméterként átadni.

Adjunk hozzá két elemet egymás után az emplace_back() függvény segítségével.

Kimenet:

Most a végső vektor négy elemet tartalmaz a „mangán” és a „réz” hozzáadása után.

Egy vektor maximális eleme

1. Hozzon létre egy vektort néhány elemmel.
2. A vektorban jelenlévő maximális elem megkereséséhez használja a *max_element() függvényt, amely két iterátort fogad el argumentumként. Ez a két paraméter tartományként működik, és a maximális elem a megadott tartományon belül kerül visszaadásra. A kezdő pozíció a begin() és az utolsó pozíció az end().

Tekintsünk egy „item_costs” nevű vektort, amely öt egész típusú értéket tartalmaz, és a maximális elemet adja vissza.

Kimenet:

Itt a 8900 a maximális elem az „item_costs” vektorban szereplő összes elem közül.

A vektor minimális eleme

1. Hozzon létre egy vektort néhány elemmel.
2. A vektorban jelenlévő minimális elem megkereséséhez használja a *min_element() függvényt, amely két iterátort fogad el argumentumként. Ez a két paraméter tartományként működik, és a minimális elem (kevesebb, mint az összes többi elem) a megadott tartományon belül kerül visszaadásra. A kezdő pozíció a begin() és az utolsó pozíció az end().

Használja ugyanazt a vektort, amelyet létrehoztunk a maximális elem és a minimális elem megkereséséhez a *min_element() függvény segítségével.

Kimenet:

Itt 200 a minimális elem az „item_costs” vektorban szereplő összes elem közül.

Elemek összege egy vektorban

A vektorban jelenlévő összes elem összegének visszaadásához a felhalmoz() függvényt használjuk a C++ STL-ben. Három paramétert fogad el. Az első paraméter veszi az első indexet, amely a tartomány kezdő elemét képviseli (adja meg a begin() iterátort), a második paraméter pedig az utolsó indexet, amely a tartomány záróelemét képviseli (adja meg az end() iterátort). Végül át kell adnunk az összeg kezdeti értékét (esetünkben ez 0).

Hozzon létre egy „tétel_költség” nevű vektort öt egész típusú elemből, és számítsa ki az összeget.

Kimenet:

A 8900, 5677, 200, 1000, 2300 összege 18077.

Két vektor elemi alapú szorzása

1. Hozzon létre két numerikus típusú vektort, és két vektornak azonos méretűnek kell lennie (az első vektorban jelenlévő elemek teljes száma = a második vektorban jelenlévő elemek teljes száma).
2. Deklaráljunk egy új vektort, és használjuk a hurokhoz , hajtsa végre a szorzást két elemen minden iterációban, és tárolja az értéket a létrehozott vektorban a push_back() függvény segítségével.
számára ( int itr = 0 ; én < first_vec. méret ( ) ; itr ++ )

{

eredmény_vektor. visszavet ( first_vec [ itr ] * sec_thing [ itr ] ) ;

}
3. Jelenítse meg az eredő vektorban szereplő elemeket az iterációval.

Hozzon létre egy „item_costs” nevű vektort öt egész típusú elemből, és számítsa ki az összeget.

Kimenet:

Két vektor pontszorzata

A C++ vektorok esetében a pontszorzat a „két vektorsorozat megfelelő bejegyzéseinek szorzatának összege”.

Szintaxis:

Használja az inner_product() függvényt a pontszorzat visszaadásához. Ez a funkció négy szükséges paramétert vesz igénybe.

Itt:

1. Az első paraméter egy iterátorra vonatkozik, amely az első vektor elejére mutat (a begin() függvény segítségével adja meg).
2. A második paraméter egy iterátorra vonatkozik, amely az első vektor végére mutat (az end() függvény segítségével adja meg).
3. A harmadik paraméter egy iterátorra vonatkozik, amely a második vektor elejére mutat (a start() függvény segítségével adja meg).
4. Utolsó paraméterként a kezdeti értéket kell átadni, amely egy egész szám a pontszorzat felhalmozásához.

Használja ugyanazt a programot, amely két vektor szorzásához készült, és az innsr_product() függvény segítségével keresse meg a két vektor pontszorzatát.

Kimenet:

Alakítsa át a halmazt vektorrá

Sokféleképpen lehet egy halmazt vektorrá alakítani úgy, hogy a halmazban felvett összes elemet vektorba adjuk át. A legjobb és legegyszerűbb módja az std::copy() függvény használata.

Szintaxis

Használja a std::copy() függvény, amely egy halmaz elemeit beszúrja a vektorba. Három paraméter kell hozzá.

Itt:

1. Az első paraméter arra a forrásiterátorra vonatkozik, amely az iterátor első elemére mutat. Itt a set a forrásiterátor, amelyet a begin() függvénnyel adunk meg.
2. Hasonlóképpen, a második paraméter az utolsó elemre mutat (end() függvény).
3. A harmadik paraméter a cél iterátorra vonatkozik, amely az iterátor első elemére mutat (amelyet a begin() függvény határozza meg).

Hozzunk létre egy halmazt öt tanulóval, és másoljuk az összes elemet egy vektorba az előző függvény segítségével.

Kimenet:

Most a „Students” készletben található összes elem átmásolódik a „students_vc” vektorba.

Távolítsa el az ismétlődő elemeket

1. Először is úgy kell rendeznünk az elemeket a vektorban, hogy az összes ismétlődő elem egymás mellett legyen a std::sort() funkció.
std :: fajta ( A vektor az első, a vektor az utolsó ) ;
2. Használja az std::unique() függvényt az ismétlődő elemek kiválasztásához. Ugyanakkor használja az erase() függvényt az std::unique() függvény által visszaadott ismétlődések eltávolításához. Az elemek sorrendje a végső vektorban változhat.
vektor. törli ( std :: egyedi ( A vektor az első, a vektor az utolsó ) , Vector utolsó ) )

Hozza létre a „tanulók” vektort 10 elemből, és adja vissza a vektort az ismétlődések eltávolításával.

Kimenet:

Most minden elem egyedi a vektorban.

Alakítson át egy vektort halmazzá

A készlet nem engedélyezi az elemek ismétlődését. Ha beír, hogy vektort szúrjon be egy ismétlődő halmazba, a rendszer figyelmen kívül hagyja azokat. Ugyanazt az std::copy() függvényt használjuk, mint az előző forgatókönyvben, amely a halmazt vektorrá alakította.

Ebben a forgatókönyvben:

1. Az első paraméter a vektort veszi forrásiterátorként, amelyet a begin() függvénnyel adunk meg.
2. A második paraméter a vektort veszi forrásiterátorként, amelyet az end() függvénnyel adunk meg.
3. Adja át az std::inserter() függvényt, amely az elemek automatikus felülírására/másolására szolgál a készlet egy adott helyén, paraméterként megadva a halmazt és az iterátort, amelyek a halmaz végére mutatnak.

Hozzunk létre egy vektort 10 egész számmal, és másoljuk az elemeket egy halmazba.

Kimenet:

A meglévő „jelek” nevű vektornak 10 értéke van. Miután bemásolta a „marks_set” készletbe, csak hat elemet tartalmaz, mivel a másik négy elem duplikálva van.

Távolítsa el az üres karakterláncokat

A vektorban jelenlévő üres karakterláncok nem használhatók. Jó gyakorlat a vektorban lévő üres karakterláncok eltávolítása. Nézzük meg, hogyan lehet eltávolítani az üres karakterláncokat a C++ vektorból:

1. Iterálja a vektort a „for” ciklus segítségével.
2. Minden iterációban ellenőrizze, hogy az elem üres-e („”), vagy nem használja az „==” operátort az at() tagfüggvénnyel.
3. Az std::erase() függvény segítségével távolítsa el az üres karakterláncokat az előző feltétel ellenőrzése után.
4. Ismételje meg a 2. és 3. lépést a vektor végéig.

Hozzuk létre a „cégek” vektort 10 karakterlánccal. Közülük öt üres, és az előző megközelítéssel eltávolítjuk őket.

Kimenet:

Most a „cégek” vektor tartalmazza a nem üres karakterláncokat.

Írjon vektort egy szövegfájlba

Beszéljük meg, hogyan írhatjuk a vektorban lévő összes elemet fájlba a vektorindexek segítségével a fstream .

1. A vektor inicializálása után toljon bele néhány elemet a push_back függvény segítségével.
2. Használja az open() függvényt az „fstream” könyvtárból úgy, hogy a mód out.
3. Menjen be a vektorban található minden elemen az indexek segítségével egy „for” ciklusban, és írja be az egyes elemeket a megadott fájlba.
4. Végül zárja be a fájlt.

Valósítsuk meg az előző megközelítést egy C++ kód futtatásával.

Kimenet:

A „v_data” vektor két elemet tartalmaz, és egy fájl jön létre azon az útvonalon, ahol a program végrehajtásra kerül a vektorban lévő elemekkel.

Vektor létrehozása szöveges fájlból

Megtanultuk, hogyan kell a vektorban található elemeket szövegfájlba írni. Itt hozzunk létre egy vektort a szövegfájlban lévő tartalomból.

1. Hozzon létre egy „ ifstream” változó, amely arra szolgál, hogy kiolvassa az információkat abból a szövegfájlból, amelyben a vektort létrehozzuk a fájlból.
2. Hozzon létre egy üres vektort a fájl tartalmának tárolására, és használjon üres karakterlánc-változót zászlóként a fájl végének ellenőrzéséhez.
3. Olvassa el a következő sort a fájlból, amíg el nem éri (alapvetően a „while” ciklus használatával). Használja a push_back() függvényt a következő sor beolvasásához és a vektorba tolásához.
4. Jelenítse meg a sorban lévő sort külön, hogy megtekinthesse a konzol vektorában található elemeket.

Valósítsuk meg az előző megközelítést a C++ kód futtatásával. Tekintsük a „data.txt” fájlt a következő tartalommal. Itt a vektor neve „v_data”.

Kimenet:

Láthatjuk, hogy a „v_data” öt elemet tartalmaz, amelyek a fájlból származtak.

Következtetés

Ebben a hosszú cikkben megvizsgáltuk az összes lehetséges példát, amelyeket a C++ programozási nyelv vektoraihoz kapcsolódó valós idejű alkalmazásokban használnak. Minden példa magyarázata a szintaxissal, paraméterekkel, a példa pedig a kimenettel. A kód egyértelmű megértése érdekében minden kódhoz megjegyzéseket adunk.