30 Příklady vektorů C++

30 Priklady Vektoru C



V C++ je Vector jednorozměrná datová struktura, která se dynamicky zvyšuje na základě požadavku. V této datové struktuře lze efektivně provádět organizaci dat (vkládání/úpravu/mazání). Jeho aplikace zahrnují následující:

  1. Reprezentace matematických vektorů ve vědeckých a technických aplikacích
  2. Pomocí této datové struktury lze implementovat fronty, zásobníky atd.

Většina běžných operací a funkcí CRUD souvisejících s touto datovou strukturou je podrobně diskutována podle scénářů se syntaxí a úryvky kódu.







Téma obsahu:

  1. Vložte prvek do vektoru
  2. Vložit více prvků do vektoru
  3. Získejte přístup k prvkům z vektoru
  4. Aktualizujte prvek ve vektoru
  5. Odstraňte konkrétní prvek z vektoru
  6. Odstraňte všechny prvky z vektoru
  7. Unie vektorů
  8. Průnik vektorů
  9. Zkontrolujte, zda je vektor prázdný nebo ne
  10. Projděte vektor pomocí Const_Iterator
  11. Projděte vektor pomocí Reverse_Iterator
  12. Zatlačte prvky do vektoru
  13. Objevte prvky z vektoru
  14. Vyměňte vektory
  15. Získejte první prvek z vektoru
  16. Získejte poslední prvek z vektoru
  17. Přiřadit nové hodnoty k vektoru
  18. Rozšiřte vektor pomocí Emplace()
  19. Rozšiřte vektor pomocí Emplace_Back()
  20. Maximální prvek vektoru
  21. Minimální prvek vektoru
  22. Součet prvků ve vektoru
  23. Element-Wise násobení dvou vektorů
  24. Bodový součin dvou vektorů
  25. Převeďte sadu na vektor
  26. Odstraňte duplicitní prvky
  27. Převeďte vektor na sadu
  28. Odstraňte prázdné řetězce
  29. Napište vektor do textového souboru
  30. Vytvořte vektor z textového souboru

Vložte prvek do vektoru

The std::vector::insert() Funkce STL v C++ se používá k vložení prvků na zadanou pozici.



Syntax:

vektor. vložit ( pozice, prvek ) ;

Využijme tuto funkci a předáme první pozici jako parametr, který určuje pozici, kam má být prvek vložen, a poskytneme prvek jako druhý parametr.



Funkci begin() lze zde použít k vrácení iterátoru, který ukazuje na první prvek vstupního vektoru. Přidáním pozice do této funkce se prvek vloží na tuto pozici.





Vytvořme vektor „jména studentů“ typu string a vložíme dva řetězce na první a druhou pozici, jeden po druhém, pomocí funkce insert().

#include

použitím jmenný prostor std ;

hlavní ( )

{

// Inicializace vektoru - jména studentů

vektor < tětiva > jména studentů ;

cout << 'Stávající vektor: \n ' ;

pro ( auto i : jména studentů ) cout << i << endl ;

// Na první pozici vložte 'Sravan Kumar'.

jména studentů. vložit ( jména studentů. začít ( ) + 0 , 'Shravan Kumar' ) ;

// Vložte 'Sravan Kumar' na druhou pozici

jména studentů. vložit ( jména studentů. začít ( ) + 1 , 'Lalitha' ) ;

cout << 'Konečný vektor: \n ' ;

pro ( auto j : jména studentů ) cout << j << endl ;

}

Výstup:

Dříve byl vektor „jména studentů“ prázdný. Po vložení vektor obsahuje dva prvky.



Vložit více prvků do vektoru

V tomto scénáři používáme stejnou funkci, jakou je std::vector::insert(). Ale potřebujeme předat extra/různé parametry stejné funkci, abychom vložili více prvků do vektoru.

Scénář 1: Vložení jednoho prvku vícekrát

V tomto scénáři přidáme stejný prvek vícekrát.

Syntax:

vektor. vložit ( pozice, velikost, prvek ) ;

Abychom to udělali, musíme funkci insert() předat jako druhý parametr velikost. Celkový počet parametrů, které jsou předány této funkci, jsou tři.

Tady:

  1. Parametr position určuje polohu prvku, který se má vložit. Pokud je velikost větší než 1, index počáteční pozice bude pozice.
  2. Parametr size určuje, kolikrát má být prvek vložen.
  3. Parametr prvku vezme prvek, který má být vložen do vektoru.

Zvažte vektor „jména studentů“ se dvěma řetězci. Vložte struny „Lavanya“ pětkrát na druhé místo.

#include

použitím jmenný prostor std ;

hlavní ( )

{

// Inicializace vektoru - jména studentů

vektor < tětiva > jména studentů { 'Shravan Kumar' , 'Lalitha' } ;

cout << 'Stávající vektor: \n ' ;

pro ( auto i : jména studentů ) cout << i << endl ;

// Vložte 'Lavanya' na druhé místo 5krát

jména studentů. vložit ( jména studentů. začít ( ) + 1 , 5 , 'Lavanya' ) ;

cout << ' \n Konečný vektor: \n ' ;

pro ( auto j : jména studentů ) cout << j << endl ;

}

Výstup:

Ve stávajícím vektoru je „Sravan Kumar“ na první pozici a „Lalitha“ je na druhé pozici. Po pětinásobném vložení „Lavanya“ (z druhé pozice na šestou pozici) se „Lalitha“ posunula na sedmou pozici (poslední).

Scénář 2: Vkládání více prvků

V tomto scénáři přidáváme různé prvky najednou z jiného vektoru. Také zde používáme stejnou funkci, ale změní se syntaxe a parametry.

Syntax:

vektor. vložit ( pozice, první_iterátor, druhý_iterátor ) ;

Abychom to udělali, musíme funkci insert() předat jako druhý parametr velikost. Celkový počet parametrů, které jsou předány této funkci, jsou tři.

Tady:

  1. Parametr position určuje polohu prvku, který se má vložit.
  2. „first_iterator“ určuje počáteční pozici, ze které mají být prvky vkládány (v podstatě se pomocí funkce begin() vrací iterátor, který ukazuje na první prvek, který je přítomen v kontejneru).
  3. „second_iterator“ určuje koncovou pozici, do které mají být prvky vloženy (v podstatě pomocí funkce end() je vrácen iterátor, který ukazuje vedle posledního bodu, který je přítomen v kontejneru).

Vytvořte dva vektory, „marks1“ a „marks2“, celočíselného typu. Vložte všechny prvky, které jsou přítomné ve vektoru „marks2“ na první pozici vektoru „marks1“.

#include

použitím jmenný prostor std ;

hlavní ( )

{

// Inicializace vektoru - marks1

vektor < int > známky1 { 100 , 89 , 90 , 78 , 98 } ;

cout << 'První vektor: \n ' ;

pro ( auto i : známky 1 ) cout << i << endl ;

// Inicializace vektoru - marks2

vektor < int > známky 2 { 56 , Čtyři pět , 65 } ;

cout << 'Druhý vektor: \n ' ;

pro ( auto j : známky 2 ) cout << j << endl ;

známky1. vložit ( začít ( známky1 ) , začněte ( známky 2 ) , konec ( známky 2 ) ) ;



// Finální vektor

cout << 'První-konečný vektor: \n ' ;

pro ( auto X : známky 1 )

cout << X << '' ;

}

Výstup:

První vektor (marks1) obsahuje pět prvků a druhý vektor (marks2) obsahuje tři prvky. Parametry begin (marks1), begin(marks2), end(marks2) jsme předali funkci „insert“ tak, že všechny prvky, které jsou přítomné ve druhém vektoru, jsou iterovány a vloženy na začátek do prvního vektoru. První vektor tedy obsahuje osm prvků.

Získejte přístup k prvkům z vektoru

1. Pomocí operátoru []

V některých scénářích můžete mít požadavek na vrácení pouze konkrétních prvků z vektoru. Vracení všech prvků není potřeba. K vrácení pouze specifických prvků na základě indexu se tedy používá operátor indexu a funkce at().

Syntax:

vektor [ index_position ]

V C++ začíná indexování od 0 pro jakoukoli datovou strukturu. Pokud prvek neexistuje, vrátí se prázdný (nevyvolá se žádná chyba nebo varování).

Zvažte vektor „produktů“ s pěti položkami. Přístup ke všem prvkům jeden po druhém pomocí pozice indexu.

#include

použitím jmenný prostor std ;

hlavní ( )

{

// Vytvořte vektor - produkty s 5 řetězci

vektor < tětiva > produkty { 'mýdlo' , 'šampon' , 'olej' , 'ovoce' , 'zelenina' } ;

//Přístup k prvkům z produktů

cout << 'První prvek:' << produkty [ 0 ] << endl ;

cout << 'Druhý prvek:' << produkty [ 1 ] << endl ;

cout << 'Třetí prvek:' << produkty [ 2 ] << endl ;

cout << 'Čtvrtý prvek:' << produkty [ 3 ] << endl ;

cout << 'Pátý element:' << produkty [ 4 ] << endl ;



// Pokuste se o přístup k 9. prvku

cout << 'Devátý element:' << produkty [ 8 ] << endl ;

}

Výstup:

Na indexu 8 není přítomen žádný prvek. Takže je vráceno prázdné.

2. Pomocí funkce At().

At() je členská funkce, která je podobná předchozímu případu použití, ale vrací výjimku „std::out_of_range“, když je jí poskytnut index mimo rozsah.

Syntax:

vektor. na ( index_position )

Této funkci musíme předat pozici indexu.

Zvažte vektor „produktů“ s pěti položkami. Přistupujte ke všem prvkům jeden po druhém pomocí pozice indexu a pokuste se získat přístup k prvku, který je přítomen na 9. pozici.

#include

použitím jmenný prostor std ;

hlavní ( )

{

// Vytvořte vektor - produkty s 5 řetězci

vektor < tětiva > produkty { 'mýdlo' , 'šampon' , 'olej' , 'ovoce' , 'zelenina' } ;

//Přístup k prvkům z produktů

cout << 'První prvek:' << produkty. na ( 0 ) << endl ;

cout << 'Druhý prvek:' << produkty. na ( 1 ) << endl ;

cout << 'Třetí prvek:' << produkty. na ( 2 ) << endl ;

cout << 'Čtvrtý prvek:' << produkty. na ( 3 ) << endl ;

cout << 'Pátý element:' << produkty. na ( 4 ) << endl ;



//Přístup k prvkům, které nejsou ve vektoru

cout << 'Devátý element:' << produkty. na ( 8 ) << endl ;

}

Výstup:

Při přístupu k 9. prvku dojde k chybě:

po vyvolání instance of 'std::out_of_range'

co ( ) : vektor :: _M_range_check : __n ( který je 8 ) >= tento - > velikost ( ) ( který je 5 )

Aktualizujte prvek ve vektoru

1. Pomocí operátoru []

Pomocí pozice indexu můžeme aktualizovat prvek ve vektoru. Operátor [] převezme pozici indexu prvku, který má být aktualizován. Nový prvek bude přiřazen tomuto operátoru.

Syntax:

Vektor [ index_position ] = Živel

Zvažte vektor „student_marks“ s pěti hodnotami. Aktualizujte prvky přítomné na indexech 1 a 3.

#include

#include

použitím jmenný prostor std ;

hlavní ( )

{

// Vytvořte vektor - student_marks

vektor < int > student_marks { 98 , 78 , 90 , 67 , 89 } ;

cout << 'Stávající značky:' << endl ;

pro ( int itr : student_marks )

cout << itr << endl ;

// Aktualizace prvku na indexu-3 na 100

student_marks [ 3 ] = 100 ;

// Aktualizace prvku na indexu-1 na 60

student_marks [ 1 ] = 60 ;

cout << 'Konečné známky:' << endl ;

pro ( int itr : student_marks )

cout << itr << endl ;

}

Výstup:

Můžeme vidět, že konečný vektor drží aktualizační prvky na indexech 1 a 3.

2. Pomocí funkce At().

Podobně jako indexový operátor je at() v podstatě členská funkce, která aktualizuje hodnotu na základě indexu v iterátoru. Pokud index zadaný uvnitř této funkce neexistuje, je vyvolána výjimka „std::out_of_range“.

vektor. na ( index_position ) = Živel

Zvažte vektor „produktů“ s pěti položkami. Aktualizujte všechny prvky přítomné ve vektoru jinými prvky.

#include

použitím jmenný prostor std ;

hlavní ( )

{

// Vytvořte vektor - produkty s 5 řetězci

vektor < tětiva > produkty { 'mýdlo' , 'šampon' , 'olej' , 'ovoce' , 'zelenina' } ;

cout << 'Stávající produkty:' << endl ;

pro ( řetězec itr : produkty )

cout << itr << endl ;

//Aktualizuji všechny řetězce

produkty. na ( 0 ) = 'Dort' ;

produkty. na ( 1 ) = 'Čokoláda' ;

produkty. na ( 2 ) = 'Ovoce' ;

produkty. na ( 3 ) = 'cibule' ;

produkty. na ( 4 ) = 'Nealkoholické nápoje' ;



cout << ' \n Finální produkty: ' << endl ;

pro ( řetězec itr : produkty )

cout << itr << endl ;

}

Výstup:

Odstraňte konkrétní prvek z vektoru

V C++ je std::vector::erase() Funkce se používá k odstranění určitého prvku/rozsahu prvků z vektoru. Prvky jsou odstraněny na základě pozic iterátoru.

Syntax:

vektor. vymazat ( pozici iterátoru )

Podívejme se na syntaxi pro odstranění konkrétního prvku z vektoru. Můžeme použít funkce begin() nebo end() k získání pozice prvku, který je přítomen ve vektoru, který má být odstraněn.

Zvažte vektor „produktů“ s pěti položkami.

  1. Odeberte třetí prvek zadáním iterátoru begin(). Begin() ukazuje na první prvek ve vektoru. Pokud k této funkci přidáme dvě, ukazuje na třetí prvek.
  2. Odeberte poslední prvek zadáním iterátoru end(). End() ukazuje na poslední prvek ve vektoru.
#include

použitím jmenný prostor std ;

hlavní ( )

{

// Vytvořte vektor - produkty s 5 řetězci

vektor < tětiva > produkty { 'mýdlo' , 'šampon' , 'olej' , 'ovoce' , 'zelenina' } ;

cout << 'Stávající produkty:' << endl ;

pro ( řetězec itr : produkty )

cout << itr << endl ;



// Odeber 3. prvek

produkty. vymazat ( produkty. začít ( ) + 2 ) ;

cout << ' \n Po odstranění 3. prvku: \n ' ;

pro ( řetězec itr : produkty )

cout << itr << endl ;

// Odstraňte poslední prvek

produkty. vymazat ( produkty. konec ( ) ) ;

cout << ' \n Po odstranění posledního prvku: \n ' ;

pro ( řetězec itr : produkty )

cout << itr << endl ;

}

Výstup:

Nyní existují pouze tři prvky („mýdlo“, „šampon“, „ovoce“), které existují ve vektoru „produkty“.

Odstraňte všechny prvky z vektoru

Scénář 1: Odstraňte řadu prvků z vektoru

Použijme funkci std::vector::erase() k odstranění více prvků v rozsahu.

Syntax:

vektor. vymazat ( iterátor první, iterátor poslední )

Dva iterátory (begin() ukazuje na první prvek a end() ukazuje na funkce posledního prvku) se používají k určení rozsahu.

Zvažte vektor „produktů“ s pěti položkami a odstraňte všechny prvky z druhé pozice. K dosažení tohoto cíle je prvním iterátorem začátek (produkty)+1, který ukazuje na druhý prvek, a druhým iterátorem je konec (produkty).

#include

použitím jmenný prostor std ;

hlavní ( )

{

// Vytvořte vektor - produkty s 5 řetězci

vektor < tětiva > produkty { 'mýdlo' , 'šampon' , 'olej' , 'ovoce' , 'zelenina' } ;

cout << 'Stávající produkty:' << endl ;

pro ( řetězec itr : produkty )

cout << itr << endl ;



// Odstraňte všechny prvky z druhé pozice

produkty. vymazat ( začít ( produkty ) + 1 ,konec ( produkty ) ) ;

cout << ' \n Finální produkty: \n ' ;

pro ( řetězec itr : produkty )

cout << itr << endl ;

}

Výstup:

Nyní existuje pouze jeden prvek („mýdlo“), který je přítomen ve vektoru „produktů“.

Scénář 2: Odstraňte všechny prvky z vektoru

Využijme std::vector::clear() funkce k odstranění všech prvků z vektoru.

Syntax:

vektor. Průhledná ( )

Této funkci nejsou předány žádné parametry.

Zvažte stejný vektor, který byl použit v prvním scénáři, a odstraňte všechny prvky pomocí funkce clear().

#include

použitím jmenný prostor std ;

hlavní ( )

{

// Vytvořte vektor - produkty s 5 řetězci

vektor < tětiva > produkty { 'mýdlo' , 'šampon' , 'olej' , 'ovoce' , 'zelenina' } ;

cout << 'Stávající produkty:' << endl ;

pro ( řetězec itr : produkty )

cout << itr << endl ;



// Odstraňte všechny prvky z produktů

produkty. Průhledná ( ) ;

cout << ' \n Finální produkty: \n ' ;

pro ( řetězec itr : produkty )

cout << itr << endl ;

}

Výstup:

Vidíme, že ve vektoru „produktů“ nejsou žádné prvky.

Unie vektorů

Operaci UNION na vektorech je možné provést pomocí funkce std::set_union(). Union vrátí jedinečné prvky z vektorů ignorováním duplicitních prvků. Této funkci musíme předat oba iterátory. Spolu s tím musí být předán výstupní iterátor, který ukládá výsledek vrácený oběma iterátory.

Syntax:

set_union ( InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator res ) ;

Tady:

  1. „První1“ ukazuje na první prvek prvního iterátoru (vektor).
  2. „Poslední1“ ukazuje na poslední prvek prvního iterátoru (vektor).
  3. „První2“ ukazuje na první prvek druhého iterátoru (vektor).
  4. „Poslední2“ ukazuje na poslední prvek druhého iterátoru (vektor).

Vytvořte dva vektory – „subjects1“ a „subjects2“ – typu integer.

  1. Seřaďte dva vektory pomocí funkce sort() předáním iterátorů.
  2. Vytvořte výstupní vektor (iterátor).
  3. Najděte spojení těchto dvou vektorů pomocí funkce std::set_union(). Jako první iterátor použijte begin() a jako poslední iterátor end().
  4. Iterováním výstupního vektoru zobrazíte prvky, které funkce vrací.
#include

#include

#include

použitím jmenný prostor std ;

hlavní ( )

{

// Vytvořte vektor - značky1

vektor < int > známky1 = { 100 , 90 , 80 , 70 , 60 } ;



// Vytvořte vektor - marks2

vektor < int > známky 2 = { 80 , 90 , 60 , 70 , 100 } ;

// Seřaďte oba vektory

seřadit ( známky 1. začít ( ) , známky 1. konec ( ) ) ;

seřadit ( známky 2. začít ( ) , známky 2. konec ( ) ) ;

vektor < int > outputVector ( známky1. velikost ( ) + známky 2. velikost ( ) ) ;

vektor < int > :: iterátor je ;

i = set_union ( známky 1. začít ( ) , známky 1. konec ( ) ,

známky 2. začít ( ) ,známky2. konec ( ) ,

outputVector. začít ( ) ) ;

cout << ' \n známky1 značky U2: \n ' ;

pro ( s = outputVector. začít ( ) ; s ! = i ; ++ s )

cout << * s << '' << ' \n ' ;

}

Výstup:

V obou vektorech (subjekty1 a subjekty2) je pouze pět jedinečných prvků.

Průnik vektorů

Nalezení průsečíku dvou vektorů je možné pomocí funkce std::set_intersection(). Průnik vrátí prvky, které jsou přítomny v obou vektorech.

Syntax:

set_intersection ( InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator res ) ;

Parametry, které jsou předány funkci set_union() mohou být předány i této funkci set_intersection().

Vytvořte dva vektory – „subjects1“ a „subjects2“ – typu integer.

  1. Seřaďte dva vektory pomocí funkce sort() předáním iterátorů.
  2. Vytvořte výstupní vektor (iterátor).
  3. Najděte průsečík těchto dvou vektorů pomocí funkce std::set_intersection(). Jako první iterátor použijte begin() a jako poslední iterátor end().
  4. Iterováním výstupního vektoru zobrazíte prvky, které funkce vrací.
#include

#include

#include

použitím jmenný prostor std ;

hlavní ( )

{

// Vytvořte vektor - značky1

vektor < int > známky1 = { 100 , 10 , 80 , 40 , 60 } ;



// Vytvořte vektor - marks2

vektor < int > známky 2 = { padesáti , 90 , 60 , 10 , 100 } ;

// Seřaďte oba vektory

seřadit ( známky1. začít ( ) , známky 1. konec ( ) ) ;

seřadit ( známky 2. začít ( ) , známky 2. konec ( ) ) ;

vektor < int > outputVector ( známky1. velikost ( ) + známky 2. velikost ( ) ) ;

vektor < int > :: iterátor je ;

i = set_intersection ( známky1. začít ( ) , známky 1. konec ( ) ,

známky 2. začít ( ) ,známky2. konec ( ) ,

outputVector. začít ( ) ) ;

cout << ' \n známky1 ∩ známky2: \n ' ;

pro ( s = outputVector. začít ( ) ; s ! = i ; ++ s )

cout << * s << '' << ' \n ' ;

}

Výstup:

V obou vektorech (subjekty1 a subjekty2) jsou přítomny pouze tři prvky.

Zkontrolujte, zda je vektor prázdný nebo ne

Před prací na vektorech je důležité zkontrolovat, zda je vektor prázdný nebo ne. V softwarových projektech je také dobrou praxí zkontrolovat, zda je vektor prázdný nebo ne, před provedením operací, jako jsou operace CRUD atd.

1. Použití Std::vector::empty()

Tato funkce vrátí 1, pokud je vektor prázdný (neobsahuje žádný prvek). V opačném případě se vrátí 0. Této funkci není předán žádný parametr.

2. Pomocí Std::vector::size()

Funkce std::vector::size() vrací celé číslo, které představuje celkový počet prvků přítomných ve vektoru.

Vytvořte dva vektory – „college1“ a „college2“. „College1“ obsahuje pět prvků a „college2“ je prázdný. Aplikujte obě funkce na oba vektory a zkontrolujte výstup.

#include

#include

#include

použitím jmenný prostor std ;

hlavní ( )

{

// Vytvořte vektor - college1

vektor < tětiva > vysoká škola1 = { 'vysoká škola-A' , 'vysoká škola-B' , 'vysoká škola-C' , 'vysoká škola-D' , 'vysoká škola-E' } ;

// Vytvořte vektor - college2

vektor < tětiva > vysoká škola2 ;

// prázdné()

cout << vysoká škola1. prázdný ( ) << endl ;

cout << vysoká škola2. prázdný ( ) << endl ;

// velikost()

cout << vysoká škola1. velikost ( ) << endl ;

cout << vysoká škola2. velikost ( ) << endl ;

}

Výstup:

Funkce empty() vrátí 0 pro „college1“ a 1 pro „college2“. Funkce size() vrátí pět pro „college1“ a 0 pro „college2“.

Projděte vektor pomocí Const_Iterator

Když pracujete na kontejnerech C++, jako jsou sady, vektory atd., je možné iterovat všechny prvky, které jsou v kontejneru přítomné, aniž byste je upravovali. The const_iterator je jedním z iterátorů, které dosahují tohoto scénáře. cbegin() (ukazuje na první prvek ve vektoru) a cend() (ukazuje na poslední prvek ve vektoru) jsou dvě funkce poskytované každým kontejnerem, který se používá k vrácení konstantního iterátoru na začátek a konec kontejneru. Při iteraci vektoru můžeme využít tyto dvě funkce.

  1. Vytvořme vektor s názvem „oddělení“ s pěti řetězci.
  2. Deklarujte const_iterator – ctr typu .
  3. Iterujte přes oddělení pomocí předchozího iterátoru pomocí cyklu „for“ a zobrazte jej.
#include

#include

použitím jmenný prostor std ;

hlavní ( )

{

// Vytvořte vektor - oddělení

vektor < tětiva > oddělení = { 'Odbyt' , 'Servis' ,

'HR' , 'TO' , 'ostatní' } ;



vektor < tětiva > :: const_iterator ctr ;

// Iterace přes oddělení pomocí const_iterator - ctr.

pro ( ctr = oddělení. cbegin ( ) ; ctr ! = oddělení. trochu ( ) ; ctr ++ ) {

cout << * ctr << endl ;

}

}

Výstup:

Projděte vektor pomocí Reverse_Iterator

The reverzní_iterátor je také iterátor, který je podobný const_iterator, ale vrací prvky obráceně. Rbegin() (ukazuje na poslední prvek ve vektoru) a rend() (ukazuje na první prvek ve vektoru) jsou dvě funkce poskytované každým kontejnerem, který se používá k návratu konstantního iterátoru na konec a začátek kontejneru.

  1. Vytvořme vektor s názvem „oddělení“ s pěti řetězci.
  2. Deklarujte reverzní_iterátor – rtr typu <řetězec>.
  3. Iterujte přes oddělení pomocí předchozího iterátoru pomocí cyklu „for“ a zobrazte jej.
#include

#include

použitím jmenný prostor std ;

hlavní ( )

{

// Vytvořte vektor - oddělení

vektor < tětiva > oddělení = { 'Odbyt' , 'Servis' ,

'HR' , 'TO' , 'ostatní' } ;



vektor < tětiva > :: reverzní_iterátor rtr ;

// Iterace přes oddělení pomocí reverse_iterator - rtr.

pro ( rtr = oddělení. začít ( ) ; rtr ! = oddělení. dělá ( ) ; rtr ++ ) {

cout << * rtr << endl ;

}

}

Výstup:

Zatlačte prvky do vektoru

Vložení nebo připojení prvků do vektoru je jednosměrné vložení, které lze provést pomocí vector::push_back() funkce.

Syntax:

vektor. zatlačit zpátky ( živel )

Vyžaduje prvek, který se má vložit do vektoru jako parametr.

Vytvořme prázdný vektor s názvem „departments“ s pěti řetězci a posouváme dva řetězce jeden po druhém pomocí funkce push_back().

#include

#include

použitím jmenný prostor std ;

hlavní ( )

{

// Inicializace vektoru - oddělení

vektor < tětiva > oddělení ;

cout << 'Aktuální oddělení:' << endl ;

pro ( auto itr = oddělení. začít ( ) ; itr ! = oddělení. konec ( ) ; ++ itr )

cout << * itr << endl ;

// Stiskněte 'Prodej'

oddělení. zatlačit zpátky ( 'Odbyt' ) ;

// Stiskněte 'IT'

oddělení. zatlačit zpátky ( 'TO' ) ;

cout << ' \n Konečná oddělení:' << endl ;

pro ( auto itr = oddělení. začít ( ) ; itr ! = oddělení. konec ( ) ; ++ itr )

cout << * itr << endl ;

}

Výstup:

Nejprve stlačíme „Prodej“. Poté se „IT“ vloží do vektoru. Nyní vektor „oddělení“ obsahuje dva prvky.

Objevte prvky z vektoru

Pokud chcete odstranit poslední položku, která je přítomna ve vektoru, použijte vector::pop_back() funkce je nejlepší přístup. Vymaže poslední prvek, který je přítomen ve vektoru.

Syntax:

vektor. pop_back ( )

Pro tuto funkci není potřeba žádný parametr. Ukazuje nedefinované chování, pokud se pokusíme odstranit poslední prvek z prázdného vektoru.

Vytvořme prázdný vektor s názvem „oddělení“ s pěti řetězci a smažeme poslední prvek pomocí předchozí funkce. Zobrazte vektor v obou případech.

#include

#include

použitím jmenný prostor std ;

hlavní ( )

{

// Inicializace vektoru - oddělení

vektor < tětiva > oddělení = { 'Odbyt' , 'TO' , 'Servis' , 'Marketing' , 'HR' } ;

cout << 'Aktuální oddělení:' << endl ;

pro ( auto itr = oddělení. začít ( ) ; itr ! = oddělení. konec ( ) ; ++ itr )

cout << * itr << endl ;



// Smaže poslední prvek

oddělení. pop_back ( ) ;

cout << ' \n Konečná oddělení:' << endl ;

pro ( auto itr = oddělení. začít ( ) ; itr ! = oddělení. konec ( ) ; ++ itr )

cout << * itr << endl ;

}

Výstup:

„HR“ je posledním prvkem, který je přítomen ve vektoru „oddělení“. Je tedy odstraněn z vektoru a konečný vektor obsahuje „Prodej“, „IT“, „Servis“ a „Marketing“.

Vyměňte vektory

The vector::swap() funkce v C++ STL se používá k záměně všech prvků, které jsou přítomny ve dvou vektorech.

Syntax:

první_vektor. vyměnit ( druhý_vektor )

Nezohledňuje velikost vektorů, ale vektory by měly být stejného typu (pokud jsou různé typy vektorů, dojde k chybě).

Vytvořme dva vektory – „ovoce“ a „zeleninu“ – typu provázku s různou velikostí. Prohoďte každý z nich a zobrazte vektory v obou případech.

#include

#include

použitím jmenný prostor std ;

hlavní ( )

{

// Inicializace vektoru - ovoce

vektor < tětiva > ovoce = { 'Jablko' , 'Mango' } ;

cout << 'Skutečné ovoce:' << endl ;

pro ( auto itr = ovoce. začít ( ) ; itr ! = ovoce. konec ( ) ; ++ itr )

cout << * itr << endl ;



// Inicializace vektoru - zelenina

vektor < tětiva > zelenina = { 'Brambor' , 'Rajče' , 'brinjal' } ;

cout << ' \n Skutečná zelenina:' << endl ;

pro ( auto itr = zelenina. začít ( ) ; itr ! = zelenina. konec ( ) ; ++ itr )

cout << * itr << endl ;



// Prohoďte prvky v obou vektorech

ovoce. vyměnit ( zelenina ) ;

cout << ' \n Ovoce po výměně:' << endl ;

pro ( auto itr = ovoce. začít ( ) ; itr ! = ovoce. konec ( ) ; ++ itr )

cout << * itr << endl ;

cout << ' \n Zelenina po výměně:' << endl ;

pro ( auto itr = zelenina. začít ( ) ; itr ! = zelenina. konec ( ) ; ++ itr )

cout << * itr << endl ;

}

Výstup:

Dříve vektor „ovoce“ obsahoval dva prvky a vektor „zelenina“ tři prvky. Po výměně obsahuje vektor „ovoce“ tři prvky a vektor „zelenina“ obsahuje dva prvky.

Získejte první prvek z vektoru

V některých případech je požadavkem vrátit pouze první prvek z vektoru. Funkce vector::front() v C++ STL načte pouze první prvek z vektoru.

Syntax:

vektor. přední ( )

Tato funkce nebude mít žádný parametr. Pokud je vektor prázdný, je vyvolána chyba.

Vytvořme dva vektory – „ovoce“ a „zeleninu“ – typu string a pokusíme se získat první prvek odděleně od těchto dvou vektorů.

#include

#include

použitím jmenný prostor std ;

hlavní ( )

{

// Vytvořte vektor - ovoce se 2 prvky

vektor < tětiva > ovoce = { 'Jablko' , 'Mango' } ;

// Vrátí první prvek

cout << ovoce. přední ( ) << endl ;



// Inicializace vektoru - zelenina

vektor < tětiva > zelenina ;

// Pokuste se vrátit první prvek

cout << zelenina. přední ( ) ;

}

Výstup:

„Jablko“ je prvním prvkem, který je přítomen ve vektoru „ovoce“. Takže je to vráceno. Ale při pokusu o načtení prvního prvku z vektoru „vegetables“ dojde k chybě, protože je prázdný.

Získejte poslední prvek z vektoru

Funkce vector::end() v C++ STL načte pouze poslední prvek z vektoru.

Syntax:

vektor. zadní ( )

Tato funkce nebude mít žádný parametr. Pokud je vektor prázdný, je vyvolána chyba.

Vytvořme dva vektory – „ovoce“ a „zeleninu“ – typu string a pokusíme se získat poslední prvek odděleně od těchto dvou vektorů.

#include

#include

použitím jmenný prostor std ;

hlavní ( )

{

// Vytvořte vektor - ovoce se 2 prvky

vektor < tětiva > ovoce = { 'Jablko' , 'Mango' } ;

// Načtení posledního prvku

cout << ovoce. zadní ( ) << endl ;



// Inicializace vektoru - zelenina

vektor < tětiva > zelenina ;

// Pokuste se načíst poslední prvek

cout << zelenina. zadní ( ) ;

}

Výstup:

„Mango“ je posledním prvkem, který je přítomen ve vektoru „ovoce“. Takže je to vráceno. Ale při pokusu o načtení posledního prvku z vektoru „vegetables“ dojde k chybě, protože je prázdný.

Přiřadit nové hodnoty k vektoru

V některých scénářích, pokud chcete aktualizovat všechny hodnoty novou hodnotou nebo vytvořit vektor se stejnými hodnotami, je nejlepším přístupem použití funkce vector::assign(). Pomocí této funkce můžeme:

  1. Vytvořte vektor se všemi podobnými prvky
  2. Upravte stávající vektor pomocí stejného prvku

Syntax:

vektor. přiřadit ( velikost, hodnota )

Tato funkce vyžaduje dva parametry.

Tady:

  1. Velikost určuje počet prvků, které mají být přiřazeny.
  2. Hodnota určuje prvek, který má být přiřazen.

Vytvořme vektor s názvem „marks1“ s pěti hodnotami a aktualizujeme tento vektor čtyřmi prvky tak, aby se všechny prvky v aktualizovaném vektoru rovnaly 20.

#include

#include

#include

použitím jmenný prostor std ;

hlavní ( )

{

// Vytvořte vektor - značky1

vektor < int > známky1 = { 100 , 90 , 80 , 70 , 60 } ;

cout << 'Skutečný vektor:' << endl ;

pro ( int i = 0 ; i < známky1. velikost ( ) ; i ++ )

cout << známky1 [ i ] << endl ;



známky1. přiřadit ( 4 , dvacet ) ;



cout << ' \n Aktualizovaný vektor:' << endl ;

pro ( int i = 0 ; i < známky1. velikost ( ) ; i ++ )

cout << známky1 [ i ] << endl ;

}

Výstup:

Dříve vektor obsahoval pět různých prvků. Nyní obsahuje pouze čtyři prvky a všechny se rovnají 20.

Rozšiřte vektor pomocí Emplace()

Již víme, že nové prvky jsou dynamicky vkládány na libovolné místo ve vektoru. Je to možné pomocí funkce vector::emplace(). Podívejme se rychle na syntaxi a parametry akceptované touto funkcí.

Syntax:

vektor. umístění ( pozice const_iterator, prvek )

Této funkci jsou předány dva povinné parametry.

Tady:

  1. První parametr zaujímá pozici, abychom mohli prvek vložit na libovolné místo. Pozici můžeme získat pomocí funkce iterátor begin() nebo end().
  2. Druhým parametrem je prvek, který se má vložit do vektoru.

Uvažujme vektor „chemikálie“ se dvěma prvky.

  1. Na první pozici vložte „Mangan“ – začít (chemikálie)
  2. Vložte „Copper“ na poslední pozici – konec (chemikálie)
  3. Vložte ‚Sulphur‘ na třetí pozici – begin(chemicals)+2
#include

#include

#include

použitím jmenný prostor std ;

hlavní ( )

{

// Vytvořte vektor - chemikálie

vektor < tětiva > Chemikálie = { 'Kyslík' , 'CO' } ;

cout << 'Skutečné chemikálie:' << endl ;

pro ( int i = 0 ; i < Chemikálie. velikost ( ) ; i ++ )

cout << Chemikálie [ i ] << endl ;



// Vložit prvek na první pozici

Chemikálie. umístění ( začít ( Chemikálie ) , 'Mangan' ) ;



// Vložení prvku na poslední pozici

Chemikálie. umístění ( konec ( Chemikálie ) , 'Měď' ) ;



// Vložit prvek na třetí pozici

Chemikálie. umístění ( začít ( Chemikálie ) + 2 , 'Síra' ) ;



cout << ' \n Konečné chemikálie:' << endl ;

pro ( int i = 0 ; i < Chemikálie. velikost ( ) ; i ++ )

cout << Chemikálie [ i ] << endl ;

}

Výstup:

Nyní konečný vektor obsahuje pět prvků (uvedených na následujícím snímku obrazovky).

Rozšiřte vektor pomocí Emplace_Back()

Prvek lze připojit (přidat na konec vektoru), což lze provést pomocí vector::emplace_back() funkce.

Syntax:

vektor. emplace_back ( živel )

Prvek, který má být připojen k vektoru, je povinné předat jako parametr.

Pojďme přidat dva prvky jeden po druhém pomocí funkce emplace_back().

#include

#include

#include

použitím jmenný prostor std ;

hlavní ( )

{

// Vytvořte vektor - chemikálie

vektor < tětiva > Chemikálie = { 'Kyslík' , 'CO' } ;

cout << 'Skutečné chemikálie:' << endl ;

pro ( int i = 0 ; i < Chemikálie. velikost ( ) ; i ++ )

cout << Chemikálie [ i ] << endl ;



// Na konec vektoru vložte mangan

Chemikálie. emplace_back ( 'Mangan' ) ;



// Na konec vektoru vložte mangan

Chemikálie. emplace_back ( 'Měď' ) ;





cout << ' \n Konečné chemikálie:' << endl ;

pro ( int i = 0 ; i < Chemikálie. velikost ( ) ; i ++ )

cout << Chemikálie [ i ] << endl ;

}

Výstup:

Nyní konečný vektor obsahuje čtyři prvky po přidání „Mangan“ a „Copper“.

Maximální prvek vektoru

  1. Vytvořte vektor s některými prvky.
  2. Chcete-li najít maximální prvek, který je přítomen ve vektoru, použijte funkci *max_element(), která akceptuje dva iterátory jako argumenty. Tyto dva parametry fungují jako rozsah a maximální prvek je vrácen v rámci poskytnutého rozsahu. Počáteční pozice je begin() a poslední pozice je end().
* max_element ( first_Index, last_Index )

Uvažujme vektor s názvem „item_costs“, který obsahuje pět hodnot typu celočíselné hodnoty a vrací maximální prvek.

#include

#include

#include

použitím jmenný prostor std ;

hlavní ( )

{

// Vytvořte vektor - item_costs

vektor < int > item_costs = { 8900 , 5677 , 200 , 1000 , 2300 } ;



cout << 'Náklady na položky: \n ' ;

pro ( int i = 0 ; i < item_costs. velikost ( ) ; i ++ )

cout << item_costs [ i ] << endl ;



// Vrátí maximální prvek z výše uvedeného vektoru - item_costs

cout << ' \n Maximální cena: ' << * max_element ( začít ( item_costs ) ,konec ( item_costs ) ) ;

}

Výstup:

Zde je 8900 maximálním prvkem ze všech prvků, které jsou přítomny ve vektoru „item_costs“.

Minimální prvek vektoru

  1. Vytvořte vektor s některými prvky.
  2. Chcete-li najít minimální prvek, který je přítomen ve vektoru, použijte funkci *min_element(), která přijímá dva iterátory jako argumenty. Tyto dva parametry fungují jako rozsah a minimální prvek (méně než všechny ostatní prvky) je vrácen v rámci poskytnutého rozsahu. Počáteční pozice je begin() a poslední pozice je end().
* min_element ( first_Index, last_Index )

Použijte stejný vektor, který je vytvořen, k nalezení maximálního prvku a nalezení minimálního prvku pomocí funkce *min_element().

#include

#include

#include

použitím jmenný prostor std ;

hlavní ( )

{

// Vytvořte vektor - item_costs

vektor < int > item_costs = { 8900 , 5677 , 200 , 1000 , 2300 } ;



cout << 'Náklady na položky: \n ' ;

pro ( int i = 0 ; i < item_costs. velikost ( ) ; i ++ )

cout << item_costs [ i ] << endl ;



// Vrátí minimální prvek z výše uvedeného vektoru - item_costs

cout << ' \n Minimální cena: ' << * min_element ( začít ( item_costs ) ,konec ( item_costs ) ) ;

}

Výstup:

Zde je 200 minimální prvek mezi všemi prvky, které jsou přítomny ve vektoru „item_costs“.

Součet prvků ve vektoru

Chcete-li vrátit součet všech prvků přítomných ve vektoru, použijte akumulovat() je použita funkce v C++ STL. Přijímá tři parametry. První parametr přebírá první index, který představuje počáteční prvek v rozsahu (určete iterátor begin()) a druhý parametr přebírá poslední index, který představuje koncový prvek v rozsahu (určete iterátor end()) . Nakonec musíme předat počáteční hodnotu součtu (v našem případě je to 0).

akumulovat ( first_index, last_index, initial_val ) ;

Vytvořte vektor s názvem „item_costs“ s pěti prvky celočíselného typu a vypočítejte součet.

#include

použitím jmenný prostor std ;

hlavní ( )

{

// Vytvořte vektor - item_costs

vektor < int > item_costs = { 8900 , 5677 , 200 , 1000 , 2300 } ;



cout << 'Náklady na položky: \n ' ;

pro ( int i = 0 ; i < item_costs. velikost ( ) ; i ++ )

cout << item_costs [ i ] << endl ;



// Vrátí součet všech prvků ve výše uvedeném vektoru - item_costs

cout << ' \n Celkové náklady: ' << akumulovat ( začít ( item_costs ) ,konec ( item_costs ) , 0 ) ;

}

Výstup:

Součet 8900, 5677, 200, 1000, 2300 je 18077.

Element-Wise násobení dvou vektorů

  1. Vytvořte dva vektory typu numeric a dva vektory musí mít stejnou velikost (celkový počet prvků přítomných v prvním vektoru = celkový počet prvků přítomných ve druhém vektoru).
  2. Deklarujte nový vektor a použijte pro smyčku , proveďte operaci násobení na dvou prvcích v každé iteraci a uložte hodnotu do vytvořeného vektoru pomocí funkce push_back().
  3. pro ( int itr = 0 ; i < first_vec. velikost ( ) ; itr ++ )

    {

    result_vector. zatlačit zpátky ( first_vec [ itr ] * sec_věc [ itr ] ) ;

    }
  4. Zobrazte prvky, které jsou přítomny ve výsledném vektoru, jeho iterací.

Vytvořte vektor s názvem „item_costs“ s pěti prvky celočíselného typu a vypočítejte součet.

#include

použitím jmenný prostor std ;

hlavní ( )

{

// Vytvořte dva vektory - produkty1 a produkty2, každý s 5 prvky

vektor < int > produkty1 = { 10 , dvacet , 30 , 40 , padesáti } ;

vektor < int > produkty2 = { padesáti , 40 , 30 , 70 , 60 } ;



vektor < int > výsledné_produkty ;



// Proveďte násobení po prvcích

pro ( int i = 0 ; i < produkty1. velikost ( ) ; i ++ ) {

výsledné_produkty. zatlačit zpátky ( produkty1 [ i ] * produkty2 [ i ] ) ;

}



// Zobrazí výsledný vektor

cout << 'Násobení vektorů: \n ' ;

pro ( int res : výsledné_produkty )

cout << res << endl ;

}

Výstup:

Opakování - 1 : 10 * padesáti => 500

Opakování - 2 : dvacet * 40 => 800

Opakování - 3 : 30 * 30 => 900

Opakování - 4 : 40 * 70 => 2800

Opakování - 5 : padesáti * 60 => 3000

Bodový součin dvou vektorů

V případě C++ vektorů je bodový součin definován jako „součet součinů odpovídajících položek dvou sekvencí vektorů“.

Syntax:

vnitřní_produkt ( Vector1 first, Vector1 last, Vector2 first, Initial_Val )

Pomocí funkce inner_product() vrátíte tečkový součin. Tato funkce přebírá čtyři požadované parametry.

Tady:

  1. První parametr odkazuje na iterátor, který ukazuje na začátek prvního vektoru (určete pomocí funkce begin()).
  2. Druhý parametr odkazuje na iterátor, který ukazuje na konec prvního vektoru (určete pomocí funkce end()).
  3. Třetí parametr odkazuje na iterátor, který ukazuje na začátek druhého vektoru (určete pomocí funkce begin()).
  4. Počáteční hodnota musí být předána jako poslední parametr, což je celé číslo pro akumulaci bodového součinu.

Použijte stejný program, který byl vytvořen pro násobení dvou vektorů, a použijte funkci innsr_product() k nalezení tečkového součinu dvou vektorů.

#include

použitím jmenný prostor std ;

hlavní ( )

{

// Vytvořte dva vektory - produkty1 a produkty2, každý s 5 prvky

vektor < int > produkty1 = { 10 , dvacet , 30 , 40 , padesáti } ;

vektor < int > produkty2 = { padesáti , 40 , 30 , 70 , 60 } ;



// Zobrazí výsledný vektor

cout << 'Dot Product of products1 and products2: ' ;

cout << vnitřní_produkt ( začít ( produkty1 ) ,konec ( produkty1 ) ,začít ( produkty2 ) , 0 ) ;

}

Výstup:

( 10 * padesáti ) + ( dvacet * 40 ) + ( 30 * 30 ) + ( 40 * 70 ) + ( padesáti * 60 )

=> 500 + 800 + 900 + 2800 + 3000

=> 8000

Převeďte sadu na vektor

Existuje mnoho způsobů, jak převést množinu na vektor předáním všech prvků, které jsou v množině vyvolány, do vektoru. Nejlepší a nejjednodušší způsob je použití funkce std::copy().

Syntax

std :: kopírovat ( sourceIterator první, sourceIterator poslední, destinationIterator první )

Použijte std::copy() funkce, která vkládá prvky z množiny do vektoru. Chce to tři parametry.

Tady:

  1. První parametr odkazuje na zdrojový iterátor, který ukazuje na první prvek v iterátoru. Set je zde iterátor zdroje, který je zadán pomocí funkce begin().
  2. Podobně druhý parametr ukazuje na poslední prvek (funkce end()).
  3. Třetí parametr odkazuje na cílový iterátor, který ukazuje na první prvek (zadaný pomocí funkce begin()) v iterátoru.

Vytvořme sadu s pěti studenty a pomocí předchozí funkce zkopírujeme všechny prvky do vektoru.

#include

použitím jmenný prostor std ;

hlavní ( )

{

// Vytvořte sadu - studenti s 5 prvky

soubor < tětiva > studentů = { 'Sravan' , 'Bobby' , 'Madhu' , 'meghana' , 'Lavanya' } ;

cout << 'Soubor: \n ' ;

pro ( řetězec i : studentů )

cout << i << endl ;



// Create Vector - student_vcof size rovna velikosti množiny

vektor < tětiva > student_vc ( studentů. velikost ( ) ) ;



// Vložení prvků ze sady - students do vektoru - student_vc.

kopírovat ( studentů. začít ( ) , studenti. konec ( ) , student_vc. začít ( ) ) ;



cout << ' \n Vektor: \n ' ;

pro ( řetězec i : student_vc )

cout << i << endl ;

}

Výstup:

Nyní jsou všechny prvky přítomné v sadě „Students“ zkopírovány do vektoru „students_vc“.

Odstraňte duplicitní prvky

  1. Nejprve musíme seřadit prvky ve vektoru tak, aby všechny duplicitní prvky spolu sousedily pomocí std::sort() funkce.
  2. std :: seřadit ( Nejprve vektor, nakonec vektor ) ;
  3. Použijte funkci std::unique(), aby byly vybrány duplicitní prvky. Současně použijte funkci erase() k odstranění duplikátů, které vrací funkce std::unique(). Pořadí prvků se může v konečném vektoru změnit.
  4. vektor. vymazat ( std :: unikátní ( Nejprve vektor, nakonec vektor ) , Vektor poslední ) )

Vytvořte vektor „studenti“ s 10 prvky a vraťte vektor odstraněním duplikátů.

#include

použitím jmenný prostor std ;

hlavní ( )

{

// Vytvořte vektor - studenti s 10 prvky

vektor < tětiva > studentů = { 'Sravan' , 'Bobby' , 'Madhu' , 'meghana' , 'Lavanya' ,

'Sravan' , 'Bobby' , 'Madhu' , 'meghana' , 'Lavanya' } ;

cout << 'Studenti: \n ' ;

pro ( řetězec i : studentů )

cout << i << '' ;



// Seřaďte všechny prvky ve vektoru studentů.

seřadit ( začít ( studentů ) , konec ( studentů ) ) ;



// Použijte funkci unique() k odstranění duplikátů pomocí funkce erase().

studentů. vymazat ( unikátní ( začít ( studentů ) , konec ( studentů ) ) , konec ( studentů ) ) ;



cout << ' \n \n Jedineční studenti: \n ' ;

pro ( auto itr = cbegin ( studentů ) ; itr ! = trochu ( studentů ) ; ++ itr ) {

cout << * itr << '' ;

}

}

Výstup:

Nyní jsou všechny prvky ve vektoru jedinečné.

Převeďte vektor na sadu

Sada nepovoluje duplicitní prvky. Pokud píšete za účelem vložení vektoru do sady s duplikáty, budou ignorovány. Použijeme stejnou funkci std::copy(), která byla použita v předchozím scénáři, který převedl sadu na vektor.

V tomto scénáři:

  1. První parametr přebírá vektor jako zdrojový iterátor, který je zadán pomocí funkce begin().
  2. Druhý parametr přebírá vektor jako zdrojový iterátor, který je zadán pomocí funkce end().
  3. Předejte funkci std::inserter(), která se používá k automatickému přepsání/kopírování prvků na konkrétní pozici v sadě poskytnutím sady a iterátoru, které ukazují na konec sady, jako parametry.

Vytvořme vektor s 10 celými čísly a zkopírujeme prvky do sady.

#include

použitím jmenný prostor std ;

hlavní ( )

{

// Vytvořte sadu - značky s 10 hodnotami

vektor < int > značky = { 12 , 3. 4 , 56 , 78 , 65 , 78 , 90 , 90 , 78 , 3. 4 } ;

cout << 'Vektor: \n ' ;

pro ( int i : značky )

cout << i << '' ;



// Create Set - marks_set o velikosti rovné velikosti vektoru

soubor < int > marks_set ;



// Vložení prvků ze sady - students do vektoru - student_vc.

kopírovat ( začít ( značky ) ,konec ( značky ) , vkladač ( sada_značek, konec ( marks_set ) ) ) ;



cout << ' \n \n Soubor: \n ' ;

pro ( int i : marks_set )

cout << i << '' ;

}

Výstup:

Stávající vektor s názvem „marks“ má 10 hodnot. Po zkopírování do sady „marks_set“ obsahuje pouze šest prvků, protože ostatní čtyři prvky jsou duplikované.

Odstraňte prázdné řetězce

Ve vektoru se nepoužívají prázdné řetězce. Je dobrým zvykem odstranit prázdné řetězce, které jsou přítomny ve vektoru. Podívejme se, jak odstranit prázdné řetězce z vektoru C++:

  1. Iterujte vektor pomocí cyklu „for“.
  2. V každé iteraci zkontrolujte, zda je prvek prázdný (“”) nebo zda není použit operátor “==” s členskou funkcí at().
  3. Pomocí funkce std::erase() odstraňte prázdné řetězce po kontrole předchozí podmínky.
  4. Opakujte krok 2 a krok 3 až do konce vektoru.

Vytvořme vektor „společnosti“ s 10 řetězci. Mezi nimi je pět prázdných a my je odstraníme implementací předchozího přístupu.

#include

#include

použitím jmenný prostor std ;

hlavní ( ) {



vektor < tětiva > společnosti { 'Společnost-A' , '' , 'Společnost-B' ,

'' , 'Společnost-C' , '' , 'Společnost-D' , '' , '' , '' } ;



// Iterujte přes společnosti

// a odstraňte prázdné prvky pomocí erase()

pro ( int itr = 1 ; itr < společnosti. velikost ( ) ; ++ itr ) {

-li ( společnosti. na ( itr ) == '' ) {

společnosti. vymazat ( společnosti. začít ( ) + itr ) ;

-- itr ;

}
}

// Zobrazení vektoru


pro ( auto & i : společnosti ) {

cout << i << endl ;

}

}

Výstup:

Nyní vektor „společnosti“ obsahuje neprázdné řetězce.

Napište vektor do textového souboru

Pojďme diskutovat o tom, jak zapsat všechny prvky, které jsou přítomné ve vektoru, do souboru pomocí vektorových indexů pomocí fstream .

  1. Po inicializaci vektoru do něj vtlačte některé prvky pomocí funkce push_back.
  2. Použijte funkci open() z knihovny „fstream“ s režimem jako out.
  3. Projděte každý prvek přítomný ve vektoru pomocí indexů ve smyčce „for“ a zapište každý prvek do poskytnutého souboru.
  4. Nakonec soubor zavřete.

Pojďme implementovat předchozí přístup spuštěním kódu C++.

#include

#include <řetězec>

#include

#include

použitím jmenný prostor std ;

hlavní ( )

{

// Vytvořte vektor - v_data

// a vložíme do něj dva prvky.

vektor < tětiva > v_data ;

v_data. zatlačit zpátky ( 'Vítejte' ) ;

v_data. zatlačit zpátky ( 'na LinuxHint' ) ;

proud f ;



// Otevřete soubor

F. OTEVŘENO ( 'written_file.txt' , ios_base :: ven ) ;

// Iterujte každý prvek vektoru a zapisujte do souboru jeden po druhém.

pro ( int i = 0 ; i < v_data. velikost ( ) ; i ++ )

{

F << v_data [ i ] << endl ;

}

// Zavřete soubor

F. zavřít ( ) ;

}

Výstup:

Vektor „v_data“ obsahuje dva prvky a v cestě, kde je spuštěn program, je vytvořen soubor s prvky, které jsou přítomny ve vektoru.

Vytvořte vektor z textového souboru

Naučili jsme se zapisovat prvky, které jsou přítomné ve vektoru, do textového souboru. Zde vytvoříme vektor z obsahu, který je přítomen v textovém souboru.

  1. Vytvořte „ ifstream“ proměnná, která slouží ke čtení informací z textového souboru, ve kterém vytváříme vektor ze souboru.
  2. Vytvořte prázdný vektor pro uložení obsahu souboru a použijte prázdnou řetězcovou proměnnou jako příznak ke kontrole konce souboru.
  3. Přečtěte si další řádek ze souboru, dokud nedosáhne konce (v podstatě pomocí smyčky „while“). Pomocí funkce push_back() přečtete další řádek a vložíte jej do vektoru.
  4. Zobrazte řádek, který je přítomen v řádku, samostatně, abyste viděli prvky, které jsou přítomny ve vektoru na konzole.

Pojďme implementovat předchozí přístup spuštěním kódu C++. Podívejme se na soubor „data.txt“ s následujícím obsahem. Zde je název vektoru „v_data“.

#include

použitím jmenný prostor std ;

hlavní ( )

{

// Otevřete textový soubor - data
ifstream soubor ( 'data.txt' ) ;

// Vytvoří vektor - v_data typu - řetězec


vektor < tětiva > v_data ;

byla tanga ;

// Přečtěte si další řádek z data.txt
// dokud nedojde na konec.


zatímco ( soubor >> byl ) {

// Přečtěte si další řádek a vložte do v_data

v_data. zatlačit zpátky ( byl ) ;

}



// Zobrazí řádek přítomný v řádku samostatně.

kopírovat ( v_data. začít ( ) , v_data. konec ( ) , ostream_iterator < tětiva > ( cout , ' \n ' ) ) ;

}

Výstup:

Vidíme, že „v_data“ obsahuje pět prvků, které pocházejí ze souboru.

Závěr

V tomto dlouhém článku jsme prozkoumali všechny možné příklady, které se používají v aplikacích v reálném čase souvisejících s vektory v programovacím jazyce C++. Každý příklad je vysvětlen syntaxí, parametry a příkladem s výstupem. Ke každému kódu jsou přidány komentáře, aby bylo možné kódu jasně porozumět.