Najbardziej przydatne funkcje elementów wektorowych C ++

C ++ Wektorowe funkcje członków można umieścić w następujących kategoriach: konstrukcja, pojemność, iteratory, dostęp do elementów i modyfikatory. Każda z tych kategorii ma wiele funkcji. Wszystkie te funkcje nie są używane w wielu aplikacjach. W tym artykule wyjaśniono najbardziej przydatne z tych funkcji. Z wyjątkiem kategorii modyfikatorów, nie więcej niż trzy funkcje dla każdej kategorii są wyjaśnione w tym artykule. Kategorię modyfikatorów można podzielić na więcej podrzędnych kategorii. W każdej z tych podrzędnych kategorii nie zostaną wyjaśnione więcej niż trzy funkcje. Jeśli więcej niż trzy funkcje mają zostać wyjaśnione dla danej kategorii, zostaną one nauczone przez ilustrację.

Program korzystania z wektora C ++ powinien zacząć od,

#włączać
#włączać

Treść artykułu

• Budowa/zniszczenie
• Pojemność
• Iterator i dostęp wektorowy
• Dostęp do elementu
• Odprzyj i cofnij się
• Wkładanie
• Przypisanie elementów (zamienniki)
• Usuwać
• Jasne
• Zamiana
• Wniosek

Budowa/zniszczenie

Poniższe segmenty kodów pokazują różne sposoby tworzenia tego samego wektora:

wektor vtr;
vtr.push_back (5.5);
vtr.push_back (6.6);
vtr.push_back (7.7);
vtr.push_back (8.8);
vtr.push_back (9.9);
wektor VTR (3); // z początkową liczbą elementów
vtr [0] = 5.5;
vtr [1] = 6.6;
vtr [2] = 7.7;
wektor VTR (5, 0.0); //NIE. Elementy: 5; Każda wartość: 0.0
wektor vtr 5.5, 6.6, 7.7, 8.8, 9.9; //inicjowanie
wektor vtr = 5.5, 6.6, 7.7, 8.8, 9.9; // Konstruowanie i kopiowanie
wektor vtr;
vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
wektor VTR1 5.5, 6.6, 7.7, 8.8, 9.9;
wektor VTR2 (VTR1);
Conster wektor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;

A Conster wektor jest wektorem, którego elementów nie można zmienić. Wartości są tylko do odczytu.

Zniszczenie

Aby zniszczyć wektor, po prostu pozwól mu wyjść z zakresu.

Pojemność

rozmiar () const no -except

Liczba elementów w wektorze jest zwracana przez tę funkcję członka. W następującym segmencie kodu wyjście to 5:

wektor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
float sz = vtr.rozmiar();
Cout << sz << '\n';
pusty () const no -except

Ta metoda zwraca true (1) Jeśli wektor nie ma elementu i fałszu (0), jeśli wektor ma co najmniej jeden element. Z następującym kodem wyjście to 1 (dla True):

wektor vtr = ;
Bool Bl = vtr.pusty();
Cout << bl << '\n';

Iterator i dostęp wektorowy

Iterator jest opracowanym wskaźnikiem. Kiedy wektor, vtr został stworzony, vtr.zaczynać() zwróciłby iterator, wskazując na pierwszy element listy. Można go następnie zwiększyć, aby uzyskać dostęp do elementów po pierwszym, odpowiednio.

Kiedy wektor, vtr został stworzony, vtr.koniec() zwróciłby iterator, wskazując tuż po ostatnim elemencie listy. Można go następnie zmniejszyć, aby uzyskać dostęp do ostatniego elementu i elementów przed ostatnim, odpowiednio. Poniższy program ilustruje to:

#włączać
#włączać
za pomocą przestrzeni nazw Std;
int main ()

wektor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
wektor:: iterator iterB = vtr.zaczynać();
ITERB ++;
wektor:: iterator itere = vtr.koniec();
itere-;
Cout << *iterB << ", " << *iterE << " << endl;
*ITERB = 66.66; *itere = 99.99;
Cout << *iterB << ", " << *iterE << " << endl;
powrót 0;

Wyjście to:

6.6, 9.9
66.66, 99.99

Dostęp do wartości dwóch elementów odczytano i zmieniono przez dwa iteratory.

Dostęp do elementu

w (i)

Jest to podobne do VTR [i] i jest lepiej. Można go użyć do odczytu lub zmiany wartości elementu. Liczenie indeksu zaczyna się od zera. Czytelnik może przetestować następujący program:

#włączać
#włączać
za pomocą przestrzeni nazw Std;
int main ()

wektor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
Cout << vtr[1] << ", " << vtr[4] << " << endl;
vtr [1] = 66.66; vtr [4] = 99.99;
Cout << vtr[1] << ", " << vtr[4] << " << endl;
powrót 0;

Wyjście to:

6.6, 9.9
66.66, 99.99

Dostęp do wartości dwóch elementów odczytano i zmieniono poprzez odniesienie.

Zwracanie pierwszej wartości

Poniższy kod zwraca (kopiuje) Pierwszy element:

wektor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
float val = vtr.przód();
Cout << val << endl;

Wyjście to 5.5. Zastosowana tutaj funkcja członka to: front ().

Zwracanie ostatniej wartości

Poniższy kod zwraca (kopiuje) ostatni element:

wektor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
float val = vtr.z powrotem();
Cout << val << endl;

Wyjście to 9.9. Zastosowana tutaj funkcja członka to: back ().

Odprzyj i cofnij się

push_back ()

Element można dołączyć z tyłu wektora. Wartość może być dosłowna lub być reprezentowana przez identyfikator. Poniższy kod to ilustruje:

float flt = 10.10;
wektor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vtr.push_back (flt);
dla (int i = 0; iCout << vtr[i] << ", ";
Cout << endl;

Oryginalna lista to:

5.5, 6.6, 7.7, 8.8, 9.9

Nowa lista to:

5.5, 6.6, 7.7, 8.8, 9.9, 10.1

pop_back ()

Ostatni element można usunąć z wektora. Poniższy kod to ilustruje:

wektor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vtr.pop_back ();
dla (int i = 0; iCout << vtr[i] << ", ";
Cout << endl;

Oryginalna lista to:

5.5, 6.6, 7.7, 8.8, 9.9

Nowa lista to:

5.5, 6.6, 7.7, 8.8

Notatka: Wektor nie ma funkcji członków push_front () i pop_front ().

Wkładanie

Wkłada przed elementem wskazany przez iterator.

Wstaw (P, E)

To wkłada element, zanim element wskazał iterator, p. e może być dosłownym lub identyfikatorem. Ilustracja:

float flt = 7.0;
wektor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
wektor:: iterator iterB = vtr.zaczynać();
ITERB ++; ITERB ++;
vtr.wstaw (iterb, flt);
dla (int i = 0; iCout << vtr[i] << ", ";
Cout << endl;

Oryginalna lista to:

5.5, 6.6, 7.7, 8.8, 9.9

Nowa lista to:

5.5, 6.6, 7, 7.7, 8.8, 9.9

Ta funkcja wkładki zwraca iterator (nie zakodowany), który wskazuje na wstawiony element.

Wstaw (P, IL)

Lista może być włożona przed elementem wskazanym przez iterator. Ilustracja:

wektor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
wektor:: iterator iterB = vtr.zaczynać();
ITERB = ITERB + 2;
vtr.wstaw (iterB, 7.1, 7.2, 7.3);
dla (int i = 0; iCout << vtr[i] << ", ";
Cout << endl;

Oryginalna lista to:

5.5, 6.6, 7.7, 8.8, 9.9

Nowa lista to:

5.5, 6.6, 7.1, 7.2, 7.3, 7.7, 8.8, 9.9

Ta funkcja wkładki zwraca iterator (nie zakodowany), który wskazuje na pierwszy włożony element.

Wstaw (P, N, T)

Wkłada tę samą wartość t, n razy, przed elementem wskazanym przez p. Ilustracja:

wektor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
wektor:: iterator iterB = vtr.zaczynać();
ITERB = ITERB + 2;
vtr.Wstaw (iterb, 3, 7.1);
dla (int i = 0; iCout << vtr[i] << ", ";
Cout << endl;

Oryginalna lista to:

5.5, 6.6, 7.7, 8.8, 9.9

Nowa lista to:

5.5, 6.6, 7.1, 7.1, 7.1, 7.7, 8.8, 9.9

Ta funkcja wkładki zwraca iterator (nie zakodowany), który wskazuje na pierwszy włożony element.

Wstaw (P, I, J)

Zakres można skopiować z innego wektora i wstawić do wektora zainteresowania. Poniższy kod to ilustruje:

wektor vtr1 = 7.1, 7.2, 7.3, 7.4, 7.5;
wektor:: iterator iterb1 = vtr1.zaczynać();
iTerb1 = iTerb1 + 1;
wektor:: iterator itere1 = vtr1.koniec();
itere1 = itere1 - 2;
wektor vtr2 = 5.5, 6.6, 7.7, 8.8, 9.9;
wektor:: iterator iterb2 = vtr2.zaczynać();
iTerb2 = iTerb2 + 2;
VTR2.wstaw (iterb2, iterb1, itere1);
dla (int i = 0; iCout << vtr2[i] << ", ";
Cout << endl;

Oryginalna lista VTR2 to:

5.5, 6.6, 7.7, 8.8, 9.9

Nowa lista VTR2 to:

5.5, 6.6, 7.2, 7.3, 7.7, 8.8, 9.9

Zasięg zidentyfikowany do kopiowania wynosi [7.2, 7.3, 7.4), wskazane jako [i, j), co oznacza ostatnią wartość, 7.4 nie jest uwzględnione.

Ta funkcja wkładki zwraca iterator (nie zakodowany), który wskazuje na pierwszy włożony element.

Przypisanie elementów (zamienniki)

Przypisywanie elementów oznacza zastąpienie elementów kopiami. Wszystkie funkcje członków przypisania, zwróć void.

przypisuj (IL)

Lista może zastąpić wszystkie elementy w danym wektorze. Lista może być dłuższa lub krótsza. Ilustracja dla krótkiej listy:

wektor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
wektor:: iterator iterB = vtr.zaczynać();
ITERB = ITERB + 2;
vtr.przypisać (55.55, 66.66, 77.77);
dla (int i = 0; iCout << vtr[i] << ", ";
Cout << endl;

Oryginalna lista to:

5.5, 6.6, 7.7, 8.8, 9.9

Nowa lista to:

55.55, 66.66, 77.77

Ilustracja dla dłuższej listy:

wektor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
wektor:: iterator iterB = vtr.zaczynać();
ITERB = ITERB + 2;
vtr.przypisać (55.55, 66.66, 77.77, 88.88, 99.99, 1010.1111);
dla (int i = 0; iCout << vtr[i] << ", ";
Cout << endl;

Oryginalna lista to:

5.5, 6.6, 7.7, 8.8, 9.9

Nowa lista to:

55.55, 66.66, 77.77, 88.88, 99.99, 1010.11

przypisanie (n, t)

Ta sama wartość, powtarzana wiele razy, może zastąpić wszystkie elementy w danym wektorze. Nowa lista może być dłuższa lub krótsza. Ilustracja dla krótkiej listy:

wektor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
wektor:: iterator iterB = vtr.zaczynać();
ITERB = ITERB + 2;
vtr.przypisać (2, 77.77);
dla (int i = 0; iCout << vtr[i] << ", ";
Cout << endl;

Oryginalna lista to:

5.5, 6.6, 7.7, 8.8, 9.9

Nowa lista to:

77.77, 77.77

przypisanie (i, j)

Zakres można skopiować z innego wektora i być używany do zastąpienia całej zawartości wektora zainteresowania. Poniższy kod to ilustruje:

wektor vtr1 = 7.1, 7.2, 7.3, 7.4, 7.5;
wektor:: iterator iterb1 = vtr1.zaczynać();
iTerb1 = iTerb1 + 1;
wektor:: iterator itere1 = vtr1.koniec();
itere1 = itere1 - 2;
wektor vtr2 = 5.5, 6.6, 7.7, 8.8, 9.9;
wektor:: iterator iterb2 = vtr2.zaczynać();
iTerb2 = iTerb2 + 2;
VTR2.Assign (ITERB1, ITERE1);
dla (int i = 0; iCout << vtr2[i] << ", ";
Cout << endl;

Oryginalna lista VTR2 to:

5.5, 6.6, 7.7, 8.8, 9.9

Nowa lista VTR2 to:

7.2, 7.3

Zasięg zidentyfikowany do kopiowania wynosi [7.2, 7.3, 7.4), wskazane jako [i, j), co oznacza ostatnią wartość, 7.4 nie jest uwzględnione.

Usuwać

Używa iteratora.

usuń (q)

Usuwa element wskazany przez Q, skracając długość wektora. Zwraca iterator wskazujący na następny element, po usunięciu. Przykład:

wektor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
wektor:: iterator iterB = vtr.zaczynać();
ITERB = ITERB + 2;
wektor:: iterator ITR = vtr.usunąć (iterB);
dla (int i = 0; iCout << vtr[i] << ", ";
Cout << endl;
Cout << *itR << endl;

Oryginalna lista to:

5.5, 6.6, 7.7, 8.8, 9.9

Wyjście to:

5.5, 6.6, 8.8, 9.9,
8.8

usuń (Q1, Q2)

Usuwa zakres elementów zaczynających się od tego iteratora Q1, do tego wskazanego przez Q2, ale wykluczając jeden z Q2 - to znaczy usuwa [Q1, Q2). Zwraca iterator wskazujący na następny element, po usunięciu zakresu. Ilustracja:

wektor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
wektor:: iterator iterB = vtr.zaczynać();
ITERB = ITERB + 2;
wektor:: iterator itere = vtr.koniec();
itere = itere - 1;
wektor:: iterator ITR = vtr.usuń (iterb, itere);
dla (int i = 0; iCout << vtr[i] << ", ";
Cout << endl;
Cout << *itR << endl;

Oryginalna lista to:

5.5, 6.6, 7.7, 8.8, 9.9

Wyjście to:

5.5, 6.6, 9.9,
9.9

Jasne

jasne()

Zwraca pustkę. Wszystkie elementy w wektorze można usunąć, zmniejszając długość wektora do zera. Oto jak:

wektor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vtr.jasne();
Cout << vtr.size() << endl;

Oryginalna lista to:

5.5, 6.6, 7.7, 8.8, 9.9

Wyjście to:

0

Zamiana

X.zamiana (y)

Elementy dwóch różnych wektorów można wymienić, niezależnie od ich różnych długości. Ilustracja:

wektor vtr1 = 1.1, 2.2, 3.3, 4.4;
wektor vtr2 = 5.5, 6.6, 7.7, 8.8, 9.9;
VTR2.swap (vtr1);
Cout << "New vtr1: ";
dla (int i = 0; iCout << vtr1[i] << ", ";
Cout << endl;
Cout << "New vtr2: ";
dla (int i = 0; iCout << vtr2[i] << ", ";
Cout << endl;

Wyjście to:

Nowy VTR1: 5.5, 6.6, 7.7, 8.8, 9.9,
Nowy VTR2: 1.1, 2.2, 3.3, 4.4,

Wniosek

Wektor C ++ ma wiele funkcji członków. Funkcje te można podzielić na następujące podkategorie: konstrukcja/zniszczenie, pojemność, iterator i dostęp wektorowy, dostęp do elementów, pchanie i pop -wstecz, wkładanie, przypisanie elementów (zamienniki), usuwanie, czyste i zamiany. Najbardziej przydatne funkcje w każdej z tych podkategorii zostały wyjaśnione powyżej.