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í:
- Reprezentace matematických vektorů ve vědeckých a technických aplikacích
- 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:
- Vložte prvek do vektoru
- Vložit více prvků do vektoru
- Získejte přístup k prvkům z vektoru
- Aktualizujte prvek ve vektoru
- Odstraňte konkrétní prvek z vektoru
- Odstraňte všechny prvky z vektoru
- Unie vektorů
- Průnik vektorů
- Zkontrolujte, zda je vektor prázdný nebo ne
- Projděte vektor pomocí Const_Iterator
- Projděte vektor pomocí Reverse_Iterator
- Zatlačte prvky do vektoru
- Objevte prvky z vektoru
- Vyměňte vektory
- Získejte první prvek z vektoru
- Získejte poslední prvek z vektoru
- Přiřadit nové hodnoty k vektoru
- Rozšiřte vektor pomocí Emplace()
- Rozšiřte vektor pomocí Emplace_Back()
- Maximální prvek vektoru
- Minimální prvek vektoru
- Součet prvků ve vektoru
- Element-Wise násobení dvou vektorů
- Bodový součin dvou vektorů
- Převeďte sadu na vektor
- Odstraňte duplicitní prvky
- Převeďte vektor na sadu
- Odstraňte prázdné řetězce
- Napište vektor do textového souboru
- 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().
#includepouž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:
- 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.
- Parametr size určuje, kolikrát má být prvek vložen.
- 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.
#includepouž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:
- Parametr position určuje polohu prvku, který se má vložit.
- „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).
- „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“.
#includepouž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.
#includepouž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.
#includepouž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 ] = ŽivelZvaž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 ) = ŽivelZvažte vektor „produktů“ s pěti položkami. Aktualizujte všechny prvky přítomné ve vektoru jinými prvky.
#includepouž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.
- 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.
- Odeberte poslední prvek zadáním iterátoru end(). End() ukazuje na poslední prvek ve vektoru.
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).
#includepouž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().
#includepouž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:
- „První1“ ukazuje na první prvek prvního iterátoru (vektor).
- „Poslední1“ ukazuje na poslední prvek prvního iterátoru (vektor).
- „První2“ ukazuje na první prvek druhého iterátoru (vektor).
- „Poslední2“ ukazuje na poslední prvek druhého iterátoru (vektor).
Vytvořte dva vektory – „subjects1“ a „subjects2“ – typu integer.
- Seřaďte dva vektory pomocí funkce sort() předáním iterátorů.
- Vytvořte výstupní vektor (iterátor).
- 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().
- Iterováním výstupního vektoru zobrazíte prvky, které funkce vrací.
#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.
- Seřaďte dva vektory pomocí funkce sort() předáním iterátorů.
- Vytvořte výstupní vektor (iterátor).
- 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().
- Iterováním výstupního vektoru zobrazíte prvky, které funkce vrací.
#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.
- Vytvořme vektor s názvem „oddělení“ s pěti řetězci.
- Deklarujte const_iterator – ctr typu
. - Iterujte přes oddělení pomocí předchozího iterátoru pomocí cyklu „for“ a zobrazte jej.
#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.
- Vytvořme vektor s názvem „oddělení“ s pěti řetězci.
- Deklarujte reverzní_iterátor – rtr typu <řetězec>.
- Iterujte přes oddělení pomocí předchozího iterátoru pomocí cyklu „for“ a zobrazte jej.
#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:
- Vytvořte vektor se všemi podobnými prvky
- Upravte stávající vektor pomocí stejného prvku
Syntax:
vektor. přiřadit ( velikost, hodnota )Tato funkce vyžaduje dva parametry.
Tady:
- Velikost určuje počet prvků, které mají být přiřazeny.
- 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:
- 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().
- Druhým parametrem je prvek, který se má vložit do vektoru.
Uvažujme vektor „chemikálie“ se dvěma prvky.
- Na první pozici vložte „Mangan“ – začít (chemikálie)
- Vložte „Copper“ na poslední pozici – konec (chemikálie)
- Vložte ‚Sulphur‘ na třetí pozici – begin(chemicals)+2
#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
- Vytvořte vektor s některými prvky.
- 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().
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
- Vytvořte vektor s některými prvky.
- 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().
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.
#includepouž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ů
- 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).
- 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(). pro ( int itr = 0 ; i < first_vec. velikost ( ) ; itr ++ )
- Zobrazte prvky, které jsou přítomny ve výsledném vektoru, jeho iterací.
{
result_vector. zatlačit zpátky ( first_vec [ itr ] * sec_věc [ itr ] ) ;
}
Vytvořte vektor s názvem „item_costs“ s pěti prvky celočíselného typu a vypočítejte součet.
#includepouž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 => 500Opaková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:
- První parametr odkazuje na iterátor, který ukazuje na začátek prvního vektoru (určete pomocí funkce begin()).
- Druhý parametr odkazuje na iterátor, který ukazuje na konec prvního vektoru (určete pomocí funkce end()).
- Třetí parametr odkazuje na iterátor, který ukazuje na začátek druhého vektoru (určete pomocí funkce begin()).
- 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ů.
#includepouž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:
- 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().
- Podobně druhý parametr ukazuje na poslední prvek (funkce end()).
- 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.
#includepouž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
- Nejprve musíme seřadit prvky ve vektoru tak, aby všechny duplicitní prvky spolu sousedily pomocí std::sort() funkce. std :: seřadit ( Nejprve vektor, nakonec vektor ) ;
- 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. 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ů.
#includepouž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:
- První parametr přebírá vektor jako zdrojový iterátor, který je zadán pomocí funkce begin().
- Druhý parametr přebírá vektor jako zdrojový iterátor, který je zadán pomocí funkce end().
- 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.
#includepouž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++:
- Iterujte vektor pomocí cyklu „for“.
- V každé iteraci zkontrolujte, zda je prvek prázdný (“”) nebo zda není použit operátor “==” s členskou funkcí at().
- Pomocí funkce std::erase() odstraňte prázdné řetězce po kontrole předchozí podmínky.
- 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 .
- Po inicializaci vektoru do něj vtlačte některé prvky pomocí funkce push_back.
- Použijte funkci open() z knihovny „fstream“ s režimem jako out.
- 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.
- 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.
- Vytvořte „ ifstream“ proměnná, která slouží ke čtení informací z textového souboru, ve kterém vytváříme vektor ze souboru.
- 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.
- 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.
- 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.