30 Voorbeelden van de C++-vectoren

In C++ is Vector een eendimensionale gegevensstructuur die zichzelf dynamisch vergroot op basis van de vereiste. Gegevensorganisatie (invoegen/wijzigen/verwijderen) kan efficiënt worden uitgevoerd in deze gegevensstructuur. De toepassingen omvatten het volgende:

1. Vertegenwoordigen van de wiskundige vectoren in wetenschappelijke en technische toepassingen
2. Wachtrijen, stapels kunnen worden geïmplementeerd met behulp van deze datastructuur, enz.

De meeste algemene CRUD-bewerkingen en -functies die verband houden met deze datastructuur worden scenariomatig gedetailleerd besproken met syntaxis en codefragmenten.

Onderwerp van inhoud:

1. Voeg een element in een vector in
2. Voeg meerdere elementen in een vector in
3. Toegang tot de elementen vanaf een vector
4. Update het element in een vector
5. Verwijder een specifiek element uit een vector
6. Verwijder alle elementen uit een vector
7. Unie van vectoren
8. Snijpunt van vectoren
9. Controleer of de vector leeg is of niet
10. Doorkruis een vector met Const_Iterator
11. Doorkruis een vector met behulp van Reverse_Iterator
12. Duw de elementen in de vector
13. Pop de elementen uit de vector
14. Verwissel de vectoren
15. Haal het eerste element uit de vector
16. Haal het laatste element uit de vector
17. Wijs nieuwe waarden toe aan een vector
18. Verleng de vector met Emplace()
19. Breid de vector uit met Emplace_Back()
20. Maximaal element van een vector
21. Minimumelement van een vector
22. Som van elementen in een vector
23. Element-gewijze vermenigvuldiging van twee vectoren
24. Puntproduct van twee vectoren
25. Converteer een set naar een vector
26. Verwijder de dubbele elementen
27. Converteer een vector naar een set
28. Verwijder de lege tekenreeksen
29. Schrijf een vector naar een tekstbestand
30. Maak een vector van een tekstbestand

Voeg een element in een vector in

De std::vector::insert() functie in C++ STL wordt gebruikt om de elementen op de opgegeven positie in te voegen.

Syntaxis:

Laten we deze functie gebruiken en de eerste positie doorgeven als parameter die de positie specificeert waar het element moet worden ingevoegd en het element als tweede parameter opgeven.

De functie begin() kan hier worden gebruikt om een ​​iterator te retourneren die naar het eerste element van de invoervector verwijst. Door de positie aan deze functie toe te voegen, wordt het element op die positie ingevoegd.

Laten we de vector “student_names” van het type string maken en twee strings invoegen op de eerste en tweede positie, de een na de ander, met behulp van de functie insert().

Uitgang:

Voorheen was de vector “student_names” leeg. Na invoeging bevat de vector twee elementen.

Voeg meerdere elementen in een vector in

We gebruiken in dit scenario dezelfde functie, std::vector::insert(). Maar we moeten de extra/verschillende parameters aan dezelfde functie doorgeven om meerdere elementen in een vector in te voegen.

Scenario 1: Eén element meerdere keren invoegen

In dit scenario voegen we hetzelfde element meerdere keren toe.

Syntaxis:

Om dit te doen, moeten we de grootte als tweede parameter doorgeven aan de functie insert(). Het totaal aantal parameters dat aan deze functie wordt doorgegeven, is drie.

Hier:

1. De parameter position specificeert de elementpositie die moet worden ingevoegd. Als de grootte groter is dan 1, is de startpositie-index de positie.
2. De parameter size specificeert het aantal keren dat een element moet worden ingevoegd.
3. De elementparameter neemt het element dat in een vector moet worden ingevoegd.

Beschouw de vector “student_names” met twee tekenreeksen. Steek de “Lavanya”-snaren vijf keer in op de tweede positie.

Uitgang:

In de bestaande vector staat “Sravan Kumar” op de eerste positie en “Lalitha” op de tweede positie. Na vijf keer “Lavanya” te hebben ingevoegd (van de tweede positie naar de zesde positie), schoof “Lalitha” op naar de zevende positie (laatste).

Scenario 2: Meerdere elementen invoegen

In dit scenario voegen we de verschillende elementen tegelijk toe vanuit een andere vector. We gebruiken hier ook dezelfde functie, maar de syntaxis en parameters zullen veranderen.

Syntaxis:

Om dit te doen, moeten we de grootte als tweede parameter doorgeven aan de functie insert(). Het totaal aantal parameters dat aan deze functie wordt doorgegeven, is drie.

Hier:

1. De parameter position specificeert de elementpositie die moet worden ingevoegd.
2. De “first_iterator” specificeert de startpositie van waaruit de elementen moeten worden ingevoegd (in principe wordt met behulp van de functie begin() een iterator geretourneerd die verwijst naar het eerste element dat aanwezig is in de container).
3. De “second_iterator” specificeert de eindpositie tot waar de elementen moeten worden ingevoegd (in principe wordt met behulp van de functie end() een iterator geretourneerd die verwijst naar het laatste punt dat aanwezig is in de container).

Maak twee vectoren, “marks1” en “marks2”, van het type geheel getal. Plaats alle elementen die aanwezig zijn in de vector 'marks2' in de eerste positie van de vector 'marks1'.

Uitgang:

De eerste vector (marks1) bevat vijf elementen en de tweede vector (marks2) bevat drie elementen. We hebben de parameters begin (marks1), begin(marks2), end(marks2) doorgegeven aan de functie 'insert', zodat alle elementen die aanwezig zijn in de tweede vector worden herhaald en aan het begin in de eerste vector worden ingevoegd. De eerste vector bevat dus acht elementen.

Toegang tot de elementen vanaf een vector

1. Gebruik van de []-operator

In sommige scenario's moet u mogelijk alleen de specifieke elementen uit de vector retourneren. Het retourneren van alle elementen is niet nodig. Om dus alleen de specifieke elementen op basis van de index terug te geven, worden de indexoperator en de functies at() gebruikt.

Syntaxis:

In C++ begint de indexering voor elke datastructuur vanaf 0. Als het element niet bestaat, wordt het leeg geretourneerd (er wordt geen fout weergegeven of er wordt een waarschuwing weergegeven).

Beschouw de vector ‘producten’ met vijf items. Krijg één voor één toegang tot alle elementen met behulp van de indexpositie.

Uitgang:

Er is geen element aanwezig in index 8. Er wordt dus leeg geretourneerd.

2. De functie At() gebruiken

At() is een lidfunctie die vergelijkbaar is met het vorige gebruiksscenario, maar retourneert de uitzondering “std::out_of_range” wanneer de index buiten bereik wordt verstrekt.

Syntaxis:

We moeten de indexpositie doorgeven aan deze functie.

Beschouw de vector ‘producten’ met vijf items. Open alle elementen één voor één met behulp van de indexpositie en probeer toegang te krijgen tot het element dat aanwezig is op de 9e positie.

Uitgang:

Er treedt een fout op bij de toegang tot het 9e element:

Update een element in een vector

1. Gebruik van de []-operator

Met behulp van de indexpositie kunnen we het element in de vector bijwerken. De operator [] neemt de indexpositie over van het element dat moet worden bijgewerkt. Het nieuwe element wordt aan deze operator toegewezen.

Syntaxis:

Beschouw de vector “student_marks” met vijf waarden. Update de elementen die aanwezig zijn in indices 1 en 3.

Uitgang:

We kunnen zien dat de uiteindelijke vector de update-elementen bevat op indices 1 en 3.

2. De functie At() gebruiken

Net als de indexoperator is at() in feite een lidfunctie die de waarde bijwerkt op basis van de index in een iterator. Als de index die in deze functie is opgegeven niet bestaat, wordt de uitzondering “std::out_of_range” gegenereerd.

Beschouw de vector ‘producten’ met vijf items. Werk alle elementen in de vector bij met andere elementen.

Uitgang:

Verwijder een specifiek element uit een vector

In C++ wordt de std::vector::erase() functie wordt gebruikt om een ​​specifiek element/reeks elementen uit een vector te verwijderen. De elementen worden verwijderd op basis van de iteratorposities.

Syntaxis:

Laten we eens kijken naar de syntaxis voor het verwijderen van het specifieke element uit een vector. We kunnen de functies begin() of end() gebruiken om de positie te bepalen van het element dat aanwezig is in de vector die moet worden verwijderd.

Beschouw de vector ‘producten’ met vijf items.

1. Verwijder het derde element door de iterator begin() op te geven. Begin() verwijst naar het eerste element in de vector. Als we er twee aan deze functie toevoegen, verwijst dit naar het derde element.
2. Verwijder het laatste element door de iterator end() op te geven. End() verwijst naar het laatste element in de vector.

Uitgang:

Nu zijn er slechts drie elementen (“zeep”, “shampoo”, “fruit”) die voorkomen in de vector “producten”.

Verwijder alle elementen uit een vector

Scenario 1: Een reeks elementen uit een vector verwijderen

Laten we de functie std::vector::erase() gebruiken om meerdere elementen in een bereik te verwijderen.

Syntaxis:

De twee iterators (begin() verwijst naar het eerste element en end() wijst naar de laatste elementfuncties) worden gebruikt om het bereik te specificeren.

Beschouw de vector “producten” met vijf items en verwijder alle elementen uit de tweede positie. Om dit te bereiken is de eerste iterator begin (producten)+1 die naar het tweede element verwijst, en de tweede iterator is end (producten).

Uitgang:

Nu is er slechts één element (“soap”) aanwezig in de vector “producten”.

Scenario 2: verwijder alle elementen uit de vector

Laten we de gebruiken std::vector::clear() functie om alle elementen uit de vector te verwijderen.

Syntaxis:

Er worden geen parameters doorgegeven aan deze functie.

Beschouw dezelfde vector die in het eerste scenario werd gebruikt en verwijder alle elementen met behulp van de functie clear().

Uitgang:

We kunnen zien dat er geen elementen zijn in de vector “producten”.

Unie van vectoren

Het is mogelijk om de UNION-bewerking op vectoren uit te voeren met behulp van de std::set_union() functie. Union retourneert de unieke elementen van de vectoren door de dubbele elementen te negeren. We moeten beide iterators aan deze functie doorgeven. Daarnaast moet een uitvoer-iterator worden doorgegeven die het resultaat opslaat dat door beide iterators wordt geretourneerd.

Syntaxis:

Hier:

1. De “first1” verwijst naar het eerste element van de eerste iterator (vector).
2. De “last1” verwijst naar het laatste element van de eerste iterator (vector).
3. De “eerste2” verwijst naar het eerste element van de tweede iterator (vector).
4. De “last2” verwijst naar het laatste element van de tweede iterator (vector).

Maak twee vectoren – “subjects1” en “subjects2” – van het type geheel getal.

1. Sorteer de twee vectoren met behulp van de functie sort() door de iteratoren door te geven.
2. Maak een uitvoervector (iterator).
3. Vind de vereniging van deze twee vectoren met behulp van de std::set_union() functie. Gebruik begin() als de eerste iterator en end() als de laatste iterator.
4. Herhaal de uitvoervector om de elementen weer te geven die door de functie worden geretourneerd.

Uitgang:

Er zijn slechts vijf unieke elementen in beide vectoren (subjects1 en subject2).

Snijpunt van vectoren

Het vinden van het snijpunt van twee vectoren kan mogelijk zijn met behulp van de std::set_intersection() functie. Intersection retourneert de elementen die aanwezig zijn in beide vectoren.

Syntaxis:

De parameters die aan de functie set_union() worden doorgegeven, kunnen ook aan deze functie set_intersection() worden doorgegeven.

Maak twee vectoren – “subjects1” en “subjects2” – van het type geheel getal.

1. Sorteer de twee vectoren met behulp van de functie sort() door de iteratoren door te geven.
2. Maak een uitvoervector (iterator).
3. Zoek het snijpunt van deze twee vectoren met behulp van de std::set_intersection() functie. Gebruik begin() als de eerste iterator en end() als de laatste iterator.
4. Herhaal de uitvoervector om de elementen weer te geven die door de functie worden geretourneerd.

Uitgang:

Er zijn slechts drie elementen aanwezig in beide vectoren (subjecten1 en subjecten2).

Controleer of de vector leeg is of niet

Voordat u aan vectoren gaat werken, is het belangrijk om te controleren of de vector leeg is of niet. Het is ook een goede gewoonte om bij softwareprojecten te controleren of de vector leeg is of niet voordat u bewerkingen uitvoert, zoals CRUD-bewerkingen, enz.

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

Deze functie retourneert 1 als de vector leeg is (geen enkel element bevat). Anders wordt 0 geretourneerd. Er wordt geen parameter doorgegeven aan deze functie.

2. Gebruik van de Std::vector::grootte()

De functie std::vector::size() retourneert het gehele getal dat het totale aantal elementen vertegenwoordigt dat in de vector aanwezig is.

Maak twee vectoren – “college1” en “college2”. “College1” bevat vijf elementen en “college2” is leeg. Pas beide functies op beide vectoren toe en controleer de uitvoer.

Uitgang:

De functie empty() retourneert 0 voor “college1” en 1 voor “college2”. De functie size() retourneert vijf voor “college1” en 0 voor “college2”.

Doorkruis een vector met behulp van de Const_Iterator

Wanneer u werkt aan C++-containers zoals sets, vectoren, enz., is het mogelijk om alle elementen die in de container aanwezig zijn te herhalen zonder ze te wijzigen. De const_iterator is een van de iterators die dit scenario realiseren. De cbegin() (wijst naar het eerste element in de vector) en cend() (wijst naar het laatste element in de vector) zijn de twee functies die door elke container worden geleverd en die worden gebruikt om de constante iterator terug te sturen naar het begin en einde van de houder. Tijdens het itereren van de vector kunnen we deze twee functies gebruiken.

1. Laten we een vector maken met de naam 'afdelingen' met vijf tekenreeksen.
2. Declareer een const_iterator – ctr van het type .
3. Herhaal de afdelingen met behulp van de vorige iterator met behulp van de “for”-lus en geef deze weer.

Uitgang:

Doorkruis een vector met behulp van de Reverse_Iterator

De omgekeerde_iterator is ook een iterator die vergelijkbaar is met de const_iterator, maar retourneert de elementen in omgekeerde volgorde. De rbegin() (wijst naar het laatste element in de vector) en rend() (wijst naar het eerste element in de vector) zijn de twee functies die door elke container worden geleverd en die wordt gebruikt om de constante iterator terug te sturen naar het einde en het begin van de houder.

1. Laten we een vector maken met de naam 'afdelingen' met vijf tekenreeksen.
2. Declareer een reverse_iterator – rtr van het type .
3. Herhaal de afdelingen met behulp van de vorige iterator met behulp van de “for”-lus en geef deze weer.

Uitgang:

Duw de elementen in de vector

Het duwen of toevoegen van de elementen in een vector is een eenrichtingsinvoeging die kan worden gedaan met behulp van de vector::push_back() functie.

Syntaxis:

Er is een element nodig om als parameter in de vector te worden geduwd.

Laten we een lege vector maken met de naam “afdelingen” met vijf strings en twee strings achter elkaar pushen met behulp van de push_back() functie.

Uitgang:

Eerst pushen we de “Verkoop”. Daarna wordt “IT” in de vector geduwd. De vector ‘afdelingen’ bevat nu twee elementen.

Pop de elementen uit de vector

Als u het laatste item dat aanwezig is in de vector wilt verwijderen, gebruikt u de vector::pop_back() Functie is de beste aanpak. Het verwijdert het laatste element dat aanwezig is in de vector.

Syntaxis:

Voor deze functie is geen parameter nodig. Het toont het ongedefinieerde gedrag als we proberen het laatste element uit een lege vector te verwijderen.

Laten we een lege vector maken met de naam “afdelingen” met vijf tekenreeksen en het laatste element verwijderen met behulp van de vorige functie. Geef de vector in beide gevallen weer.

Uitgang:

“HR” is het laatste element dat aanwezig is in de vector “afdelingen”. Het wordt dus uit de vector verwijderd en de uiteindelijke vector bevat “Verkoop”, “IT”, “Service” en “Marketing”.

Verwissel de vectoren

De vector::wissel() functie in C++ STL wordt gebruikt om alle elementen die aanwezig zijn in twee vectoren om te wisselen.

Syntaxis:

Er wordt geen rekening gehouden met de grootte van de vectoren, maar de vectoren moeten van hetzelfde type zijn (er wordt een fout gegenereerd als de vectortypen verschillend zijn).

Laten we twee vectoren maken – ‘fruit’ en ‘groenten’ – van het stringtype met verschillende groottes. Verwissel ze allemaal en geef in beide gevallen de vectoren weer.

Uitgang:

Voorheen bevatte de vector “fruit” twee elementen en de vector “groenten” drie elementen. Na het verwisselen bevat de vector “fruit” drie elementen en de vector “groenten” twee elementen.

Haal het eerste element uit de vector

In sommige gevallen is het de vereiste om alleen het eerste element uit de vector terug te geven. De functie vector::front() in C++ STL haalt alleen het eerste element uit de vector op.

Syntaxis:

Deze functie gebruikt geen enkele parameter. Als de vector leeg is, wordt er een fout gegenereerd.

Laten we twee vectoren maken – “fruit” en “groenten” – van het stringtype en proberen het eerste element afzonderlijk van de twee vectoren op te halen.

Uitgang:

“Appel” is het eerste element dat aanwezig is in de vector “fruit”. Het wordt dus teruggestuurd. Maar er wordt een fout gegenereerd wanneer we proberen het eerste element uit de vector 'groenten' op te halen, omdat deze leeg is.

Haal het laatste element uit de vector

De functie vector::end() in C++ STL haalt alleen het laatste element uit de vector op.

Syntaxis:

Deze functie gebruikt geen enkele parameter. Als de vector leeg is, wordt er een fout gegenereerd.

Laten we twee vectoren maken – “fruit” en “groenten” – van het stringtype en proberen het laatste element afzonderlijk van de twee vectoren op te halen.

Uitgang:

“Mango” is het laatste element dat aanwezig is in de vector “fruit”. Het wordt dus teruggestuurd. Maar er wordt een fout gegenereerd wanneer we proberen het laatste element uit de vector 'groenten' op te halen, omdat deze leeg is.

Wijs nieuwe waarden toe aan een vector

Als u in sommige scenario's alle waarden wilt bijwerken met de nieuwe waarde of een vector met dezelfde waarden wilt maken, is het gebruik van de functie vector::assign() de beste aanpak. Met behulp van deze functie kunnen we:

1. Maak de vector met alle vergelijkbare elementen
2. Wijzig de bestaande vector met hetzelfde element

Syntaxis:

Voor deze functie zijn twee parameters vereist.

Hier:

1. De grootte specificeert het aantal toe te wijzen elementen.
2. De waarde specificeert het toe te wijzen element.

Laten we een vector maken met de naam “marks1” met vijf waarden en deze vector bijwerken met vier elementen, zodat alle elementen in de bijgewerkte vector gelijk zijn aan 20.

Uitgang:

Voorheen bevatte de vector vijf verschillende elementen. Nu bevat het slechts vier elementen en ze zijn allemaal gelijk aan 20.

Verleng de vector met Emplace()

We weten al dat nieuwe elementen dynamisch op elke positie in een vector worden ingevoegd. Het is mogelijk met behulp van de functie vector::emplace(). Laten we snel kijken naar de syntaxis en parameters die door deze functie worden geaccepteerd.

Syntaxis:

Er worden twee verplichte parameters aan deze functie doorgegeven.

Hier:

1. De eerste parameter neemt de positie in, zodat we het element op elke positie kunnen invoegen. We kunnen de positie verkrijgen met behulp van de iteratorfunctie begin() of end().
2. De tweede parameter is het element dat in de vector moet worden ingevoegd.

Beschouw de “chemische” vector met twee elementen.

1. Voeg “Mangaan” in op de eerste positie – begin(chemicaliën)
2. Voeg “Koper” in op de laatste positie – einde(chemicaliën)
3. Voeg ‘Zwavel’ in op de derde positie – begin(chemicaliën)+2

Uitgang:

Nu bevat de uiteindelijke vector vijf elementen (weergegeven in de volgende schermafbeelding).

Breid de vector uit met Emplace_Back()

Er kan een element worden toegevoegd (toegevoegd aan het einde van de vector), wat gedaan kan worden met behulp van de vector::emplace_back() functie.

Syntaxis:

Het is verplicht om het element dat aan de vector moet worden toegevoegd als parameter door te geven.

Laten we twee elementen achter elkaar toevoegen met behulp van de emplace_back() functie.

Uitgang:

Nu bevat de uiteindelijke vector vier elementen na toevoeging van “Mangaan” en “Koper”.

Maximaal element van een vector

1. Maak een vector met enkele elementen.
2. Om het maximale element te vinden dat aanwezig is in de vector, gebruikt u de functie *max_element() die twee iterators als argumenten accepteert. Deze twee parameters fungeren als het bereik en het maximale element wordt geretourneerd binnen het opgegeven bereik. De startpositie is begin() en de laatste positie is end().

Laten we een vector bekijken met de naam 'item_costs' die vijf waarden van het gehele type bevat en het maximale element retourneert.

Uitgang:

Hier is 8900 het maximale element van alle elementen die aanwezig zijn in de vector ‘item_costs’.

Minimumelement van een vector

1. Maak een vector met enkele elementen.
2. Om het minimale element te vinden dat aanwezig is in de vector, gebruikt u de functie *min_element() die twee iterators als argumenten accepteert. Deze twee parameters fungeren als het bereik en het minimumelement (minder dan alle andere elementen) wordt geretourneerd binnen het opgegeven bereik. De startpositie is begin() en de laatste positie is end().

Gebruik dezelfde vector die is gemaakt om het maximale element te vinden en vind het minimale element met behulp van de functie *min_element().

Uitgang:

Hier is 200 het minimumelement van alle elementen die aanwezig zijn in de vector “item_costs”.

Som van elementen in een vector

Om de som te retourneren van alle elementen die aanwezig zijn in de vector, moet de accumuleren() functie in C++ STL wordt gebruikt. Het accepteert drie parameters. De eerste parameter neemt de eerste index die het startelement in het bereik vertegenwoordigt (specificeer de begin() iterator) en de tweede parameter neemt de laatste index die het eindelement in het bereik vertegenwoordigt (specificeer de end() iterator). Ten slotte moeten we de beginwaarde van de som doorgeven (in ons geval is dit 0).

Maak een vector met de naam “item_costs” met vijf elementen van het gehele type en bereken de som.

Uitgang:

De som van 8900, 5677, 200, 1000, 2300 is 18077.

Element-gewijze vermenigvuldiging van twee vectoren

1. Maak twee vectoren met het type numeriek en twee vectoren moeten dezelfde grootte hebben (totaal aantal elementen aanwezig in de eerste vector = totaal aantal elementen aanwezig in de tweede vector).
2. Declareer een nieuwe vector en gebruik de for loop , voer de vermenigvuldigingsbewerking uit op twee elementen in elke iteratie en sla de waarde op in de gemaakte vector met behulp van de push_back() functie.
voor ( int itr = 0 ; i < eerste_vec. maat ( ) ; itr ++ )

{

resultaat_vector. terugduwen ( eerste_vec [ itr ] * sec_ding [ itr ] ) ;

}
3. Geef de elementen weer die aanwezig zijn in de resulterende vector door deze te herhalen.

Maak een vector met de naam “item_costs” met vijf elementen van het gehele type en bereken de som.

Uitgang:

Puntproduct van twee vectoren

In het geval van C++-vectoren wordt het puntproduct gedefinieerd als de “som van de producten van de overeenkomstige gegevens van de twee reeksen vectoren”.

Syntaxis:

Gebruik de inner_product() functie om het puntproduct te retourneren. Deze functie heeft vier vereiste parameters nodig.

Hier:

1. De eerste parameter verwijst naar een iterator die naar het begin van de eerste vector verwijst (specificeer met de functie begin()).
2. De tweede parameter verwijst naar een iterator die naar het einde van de eerste vector verwijst (specificeer met de functie end()).
3. De derde parameter verwijst naar een iterator die naar het begin van de tweede vector verwijst (specificeer met de functie begin()).
4. De initiële waarde moet worden doorgegeven als de laatste parameter, die een geheel getal is voor de accumulatie van het puntproduct.

Gebruik hetzelfde programma dat is gemaakt voor de vermenigvuldiging van twee vectoren en gebruik de functie innsr_product() om het puntproduct van de twee vectoren te vinden.

Uitgang:

Converteer een set naar een vector

Er zijn veel manieren om een ​​set in een vector om te zetten, door alle elementen die in een set voorkomen, door te geven aan een vector. De beste en eenvoudigste manier is het gebruik van de std::copy() functie.

Syntaxis

Gebruik de std::kopie() functie die de elementen uit een set in de vector invoegt. Er zijn drie parameters nodig.

Hier:

1. De eerste parameter verwijst naar de bron-iterator die verwijst naar het eerste element in de iterator. Hier is set de bron-iterator die is opgegeven met behulp van de functie begin().
2. Op dezelfde manier verwijst de tweede parameter naar het laatste element (functie end()).
3. De derde parameter verwijst naar de doel-iterator die verwijst naar het eerste element (opgegeven met de functie begin()) in de iterator.

Laten we een set maken met vijf leerlingen en alle elementen naar een vector kopiëren met behulp van de vorige functie.

Uitgang:

Nu worden alle elementen die aanwezig zijn in de set “Studenten” gekopieerd naar de vector “students_vc”.

Verwijder de dubbele elementen

1. Eerst moeten we de elementen in de vector sorteren, zodat alle dubbele elementen naast elkaar liggen met behulp van de std::sort() functie.
soa :: soort ( Vector eerst, Vector als laatste ) ;
2. Gebruik de std::unique() functie zodat de dubbele elementen worden geselecteerd. Gebruik tegelijkertijd de functie erase() om de duplicaten te verwijderen die worden geretourneerd door de functie std::unique(). De volgorde van de elementen kan veranderen in de uiteindelijke vector.
vector. wissen ( soa :: uniek ( Vector eerst, Vector als laatste ) , Vector laatste ) )

Creëer de “studenten”-vector met 10 elementen en retourneer de vector door de duplicaten te verwijderen.

Uitgang:

Nu zijn alle elementen uniek in de vector.

Converteer een vector naar een set

Set staat geen dubbele elementen toe. Als u typt om een ​​vector in te voegen in een set met duplicaten, worden deze genegeerd. We gebruiken dezelfde std::copy() functie die werd gebruikt in het vorige scenario en die de set in een vector converteerde.

In dit scenario:

1. De eerste parameter gebruikt de vector als de bron-iterator die is opgegeven met de functie begin().
2. De tweede parameter gebruikt de vector als de bron-iterator die is opgegeven met de functie end().
3. Geef de functie std::inserter() door die wordt gebruikt om de elementen automatisch op een specifieke positie in de set te overschrijven/kopiëren door de set en iterator die naar het einde van de set verwijzen als parameters op te geven.

Laten we een vector maken met 10 gehele getallen en de elementen naar een set kopiëren.

Uitgang:

De bestaande vector genaamd “marks” heeft 10 waarden. Nadat het naar de set “marks_set” is gekopieerd, bevat het slechts zes elementen omdat de andere vier elementen worden gedupliceerd.

Verwijder de lege tekenreeksen

Er wordt geen gebruik gemaakt van lege strings die aanwezig zijn in een vector. Het is een goede gewoonte om de lege strings die in de vector aanwezig zijn te verwijderen. Laten we eens kijken hoe we de lege tekenreeksen uit de C++-vector kunnen verwijderen:

1. Herhaal de vector met behulp van de 'for' -lus.
2. Controleer in elke iteratie of het element leeg is (“”) of gebruik de operator “==” niet met de lidfunctie at().
3. Gebruik de functie std::erase() om de lege tekenreeksen te verwijderen nadat u de vorige voorwaarde hebt gecontroleerd.
4. Herhaal stap 2 en stap 3 tot het einde van de vector.

Laten we de vector ‘bedrijven’ maken met 10 tekenreeksen. Daarvan zijn er vijf leeg en we verwijderen ze door de vorige aanpak te implementeren.

Uitgang:

Nu bevat de vector “bedrijven” de niet-lege tekenreeksen.

Schrijf een vector naar een tekstbestand

Laten we bespreken hoe we alle elementen die aanwezig zijn in een vector naar een bestand kunnen schrijven met behulp van de vectorindexen met behulp van de fstroom .

1. Duw er enkele elementen in met behulp van de push_back-functie na het initialiseren van de vector.
2. Gebruik de functie open() uit de “fstream”-bibliotheek met de modus uit.
3. Doorloop elk element dat aanwezig is in de vector met behulp van de indices in een “for”-lus en schrijf elk element naar het opgegeven bestand.
4. Sluit ten slotte het bestand.

Laten we de vorige aanpak implementeren door een C++-code uit te voeren.

Uitgang:

De vector “v_data” bevat twee elementen en er wordt een bestand aangemaakt in het pad waar het programma wordt uitgevoerd met de elementen die aanwezig zijn in de vector.

Maak een vector van een tekstbestand

We hebben geleerd hoe we de elementen die in de vector aanwezig zijn, naar een tekstbestand kunnen schrijven. Laten we hier een vector maken van de inhoud die aanwezig is in het tekstbestand.

1. Creëer een ' ifstream” variabele die wordt gebruikt om de informatie uit het tekstbestand te lezen waarin we de vector uit het bestand maken.
2. Maak een lege vector om de bestandsinhoud op te slaan en gebruik een lege stringvariabele als vlag om het einde van het bestand te controleren.
3. Lees de volgende regel uit het bestand totdat deze het einde bereikt (in principe met behulp van de “while”-lus). Gebruik de push_back() functie om de volgende regel te lezen en deze in de vector te duwen.
4. Geef de lijn die in de lijn aanwezig is afzonderlijk weer om de elementen te zien die aanwezig zijn in de vector op de console.

Laten we de vorige aanpak implementeren door de C++-code uit te voeren. Laten we eens kijken naar het bestand “data.txt” met de volgende inhoud. Hier is de naam van de vector “v_data”.

Uitgang:

We kunnen zien dat “v_data” vijf elementen bevat die uit het bestand komen.

Conclusie

In dit lange artikel hebben we alle mogelijke voorbeelden onderzocht die worden gebruikt in realtime toepassingen met betrekking tot vectoren in de programmeertaal C++. Elk voorbeeld wordt uitgelegd met syntaxis, parameters en een voorbeeld met uitvoer. Aan elke code wordt commentaar toegevoegd om een ​​duidelijk begrip van de code te krijgen.