vectors stl
Rolle von Vektoren in STL mit Beispielen.
Bisher haben wir in dieser C ++ - Serie statische Arrays mit fester Größe gesehen.
Wenn wir in der Mitte des Programms mehr Elemente im Array speichern müssen, wird dies unmöglich und wir werden mit Sicherheit die Ausnahme 'out_of_bound' erhalten, sobald wir versuchen, Elemente außerhalb der Array-Grenzen zu speichern.
Eine Lösung hierfür besteht darin, das Array mit der maximalen Kapazität deklarieren zu lassen, damit beim Speichern weiterer Elemente zur Laufzeit keine Probleme auftreten. Diese Anordnung hat jedoch einen schwerwiegenden Nachteil darin, dass wir zu viel Speicher verschwenden.
=> Überprüfen Sie hier die komplette C ++ - Schulungsserie.
Die Antwort auf all diese Probleme besteht darin, ein dynamisches Array zu verwenden, das sich bei Bedarf von selbst erweitert. STL stellt dieses dynamische Array in Form eines Vektorcontainers bereit.
Was du lernen wirst:
- Wie definieren wir Vektoren?
- Deklarieren eines Vektors in C ++ mit der Klasse std :: Vector
- Vektor initialisieren
- Vektoriterator
- Vektorfunktionen
- Vektorkapazität
- Vektormodifikatoren
- 2D-Vektor
- Vektorbeispiel
- Fazit
- Literatur-Empfehlungen
Wie definieren wir Vektoren?
Vektoren sind dynamische Array-Container, deren Größe sich automatisch ändert, wenn Elemente eingefügt oder gelöscht werden. Die Speicherung des Vektors wird vom Vektorcontainer selbst übernommen.
Die Elemente im Vektor werden an zusammenhängenden Stellen gespeichert. Genau wie Arrays können auch Vektorelemente mithilfe von Iteratoren durchlaufen und darauf zugegriffen werden.
Deklarieren eines Vektors in C ++ mit der Klasse std :: Vector
In der STL-Vektorklasse std :: vector Wird unter der Überschrift definiert. Um einen Vektorcontainer zu verwenden, sollten wir diesen Header wie folgt in unser Programm aufnehmen:
#include
Wir können einen leeren Vektor wie unten gezeigt deklarieren:
std::vector myvec;
Die obige Codezeile erstellt einen Vektor mit den Elementen vom Typ Integer. In Erinnerung wird dies als myvec ausgelegt.
Vektor initialisieren
Wir können einen Vektor mit dem Wert zum Zeitpunkt der Deklaration initialisieren.
kostenlos online youtube to mp4 converter
Dies geschieht wie folgt:
#include int main() { std::vector myvec = {1, 1, 2, 3, 5}; }
Im obigen Code deklarieren wir einen Vektor vom Typ int mit dem Namen myvec, der die ersten fünf Elemente in der Fibonacci-Sequenz enthält.
Das Speicherlayout dieses Vektors ist wie folgt:
Vektoriterator
Wie bereits erwähnt, verwenden wir Iteratoren, um den Vektor nacheinander zu durchlaufen.
Vektoren unterstützen die folgenden Iteratorfunktionen zum Durchlaufen der Elemente:
- Start() - Gibt den Iterator zurück, der auf das erste Element des Vektorcontainers zeigt.
- Ende() - Gibt einen Iterator zurück, der auf das Element zeigt, das auf das letzte Element im Vektor folgt.
- rbegin () - Gibt einen umgekehrten Iterator zurück, der auf das letzte Element im Vektorcontainer zeigt.
- render () - Gibt einen umgekehrten Iterator zurück, der auf das erste Element des Vektorcontainers zeigt.
- cbegin() – Gibt einen konstanten Iterator zurück, der auf das erste Element im Vektorcontainer zeigt.
- ein paar() - Gibt einen konstanten Iterator zurück, der auf das Element zeigt, das dem letzten Element des Vektorcontainers folgt.
- crbegin () - Gibt einen Iterator mit umgekehrter Konstante zurück, der auf das letzte Element im Vektorcontainer zeigt.
- crend () - Gibt einen Iterator mit umgekehrter Konstante zurück, der auf das erste Element im Vektorcontainer zeigt.
Sehen wir uns ein Beispiel an, das diese Iteratorfunktionen demonstriert.Die anderen Funktionen können ähnlich verwendet werden.
#include #include using namespace std; int main() { vector v1; for (int i = 1; i <= 5; i++) v1.push_back(i+1); cout << 'Output of Vector with begin and end: '; for (auto i = v1.begin(); i != v1.end(); ++i) cout << *i << ' '; cout << '
Output of Vector with rbegin and rend: '; for (auto itr = v1.rbegin(); itr != v1.rend(); ++itr) cout << *itr << ' '; cout << '
Output Vector of with cbegin and cend: '; for (auto itc = v1.cbegin(); itc != v1.cend(); ++itc) cout << *itc << ' '; cout << '
Output Vector of with crbegin and crend : '; for (auto icr = v1.crbegin(); icr != v1.crend(); ++icr) cout << *icr << ' '; return 0; }
Ausgabe:
Ausgabe des Vektors mit Anfang und Ende: 2 3 4 5 6
Ausgabe des Vektors mit Beginn und Wiedergabe: 6 5 4 3 2
Ausgabe Vektor von mit cbegin und cend: 2 3 4 5 6
Ausgabe Vektor von mit crbegin und crend: 6 5 4 3 2
Daher deklarieren wir in diesem Code einen Vektor und fügen mit der Funktion push_back Werte ein. Dann zeigen wir die Vektoren unter Verwendung jeder der oben beschriebenen Iteratorfunktionen an. Wie Sie aus der Ausgabe sehen, ändert sich in Abhängigkeit von den verwendeten Iteratorfunktionen die Reihenfolge, in der der Vektor angezeigt wird.
Vektorfunktionen
Vektor sortieren
Wir können STL-Algorithmen verwenden, die wir bereits auf dem Vektor gesehen haben.
Im Folgenden finden Sie ein Beispiel für die Verwendung von 'Sortieren' für den Vektor.
#include #include #include using namespace std; int main() { vector myvec = {10,50,30,20,60,40}; cout<<'Original Vector'< Ausgabe:
Ursprünglicher Vektor
10 50 30 20 60 40
Sortierter Vektor
10 20 30 40 50 60
Im obigen Beispiel haben wir einen Vektor initialisiert und dann einen Sortieralgorithmus angewendet, um den Vektor zu sortieren.
Drucken von Elementen eines Vektors
Vektoren können mithilfe eines Iterators und eines Cout-Streams gedruckt werden. Wir können einen Iterator verwenden, um jedes der Vektorelemente zu durchlaufen und sie mit cout zu drucken.
Das folgende Beispiel zeigt dies:
#include #include using namespace std; int main() { vector v1; for (int i = 1; i <= 5; i++) v1.push_back(i+2); cout << 'Output of Vector with begin and end: '; for (auto i = v1.begin(); i != v1.end(); ++i) cout << *i << ' '; }
Ausgabe:
Ausgabe des Vektors mit Anfang und Ende: 3 4 5 6 7
Vektorkapazität
Es gibt verschiedene Funktionen, die auf Vektoren einwirken, um deren Größe, maximale Größe usw. zu bestimmen.
Wir listen die Funktionen wie folgt auf:
(i) Größe des Vektors
Die Funktion size () gibt die Anzahl der Elemente im Vektorcontainer zurück. Dies ist die integrierte Funktion der Klasse std :: vector und kann direkt zum Ermitteln der Größe des Vektors verwendet werden.
wie man einen .bin öffnet
Sehen wir uns ein Beispiel eines Vektors mit der Funktion size () an:
#include #include using namespace std; int main() { vector myvec = {1, 1, 2, 3, 5, 8}; cout << 'Vector Size : ' << myvec.size(); return 0; }
Ausgabe:
Vektorgröße: 6
Im obigen Programm haben wir einen Vektor myvec definiert, der aus sechs Elementen besteht. Als nächstes rufen wir die Funktion size () auf myvec auf und sie zeigt die richtige Größe an.
(ii) Ändern der Größe eines Vektors
Wir können die Größe eines Vektors auch auf die gewünschte Größe ändern, sodass er n Elemente enthalten kann. Dies wird durch die Funktion 'resize ()' der Klasse std :: vector erreicht. Die Größenänderungsfunktion verwendet die Größe des Vektors als Parameter und ändert dann die Größe des Vektorcontainers auf die angegebene Größe.
Lassen Sie uns dies anhand eines Beispiels verstehen.
#include #include using namespace std; int main() { vector myvec = {1, 1, 2, 3, 5, 8}; cout << '
Vector elements are: '; for (auto it = myvec.begin(); it != myvec.end(); it++) cout << *it << ' '; myvec.resize(4); cout << '
Vector Size after resize: ' << myvec.size(); cout << '
Vector elements after resizing are: '; for (auto it = myvec.begin(); it != myvec.end(); it++) cout << *it << ' '; return 0; }
Ausgabe:
Vektorelemente sind: 1 1 2 3 5 8
Vektorgröße nach Größenänderung: 4
Vektorelemente nach der Größenänderung sind: 1 1 2 3
Im obigen Programm definieren wir zunächst einen Vektor myvec der Größe 6. Dann rufen wir die Größenänderungsfunktion für diesen Vektor mit der Größe = 4 auf. Dies bedeutet, dass wir unseren Vektor jetzt auf Größe 4 ändern möchten.
Nach dem Aufruf der Größenänderungsfunktion drucken wir den Vektor erneut. Wir sehen, dass, wenn wir die Größe des Vektors auf Größe 4 ändern, die verbleibenden Elemente verworfen werden und nur die 4 Elemente des Vektors angezeigt werden.
Neben Größen- und Größenänderungsfunktionen unterstützt die Vektorklasse noch einige weitere Funktionen, mit denen wir die Kapazität des Vektors manipulieren können. Sie sind:
- maximale Größe(): Gibt die maximale Größe zurück, d. H. Die maximale Anzahl von Elementen, die der Vektor enthalten kann.
- Kapazität(): Gibt die Größe des aktuell zugewiesenen Speicherplatzes zurück. Dies wird in Bezug auf die Anzahl der Elemente zurückgegeben.
- leer(): Überprüft, ob der Container leer ist.
- schrumpfen bis es passt(): Verkleinert die Vektorkapazität entsprechend der Größe und verwirft alle anderen Elemente.
- Reservieren(): Reserviert die Vektorkapazität für n Elemente.
Vektormodifikatoren
Modifikatoren sind Operationen oder Funktionen, mit denen der Inhalt des Vektorcontainers geändert werden kann. Wir werden einige der Hauptfunktionen sehen, die als Modifikatoren verwendet werden.
Zuweisen neuer Werte zum Vektor
Eine der Modifikatorfunktionen von std :: vector ist die Zuweisungsfunktion. Die Zuweisungsfunktion weist dem Vektor neue Werte zu, indem die alten ersetzt werden.
Dies wird im folgenden Beispiel demonstriert.
#include #include using namespace std; int main() { // Assign vector vector myvec; // assign value 10 5 times myvec.assign(5, 10); cout << 'The vector elements: '; for (int i = 0; i < myvec.size(); i++) cout << myvec[i] << ' '; }
Ausgabe:
Die Vektorelemente: 10 10 10 10 10
Im obigen Code deklarieren wir einen Vektor vom Typ int. Dann rufen wir auf, um eine Funktion mit den Parametern 5, 10 zuzuweisen. Dies bedeutet, dass wir beabsichtigen, dem Vektor das Element 10 fünfmal zuzuweisen. Wenn wir den Vektor anzeigen, sehen wir, dass der Vektor 5 Elemente hat, alle mit dem Wert 5.
Einen Vektor löschen
Die nächste von std :: vector bereitgestellte Funktion zum Ändern eines Vektors ist die Löschfunktion. Die Löschfunktion entfernt die Elemente aus dem angegebenen Bereich oder eine Position aus dem Vektor.
Sehen wir uns ein Beispiel für die Löschfunktion an.
#include #include using namespace std; int main() { // Initialize vector vector myvec = {1,1,2,3,5}; cout << '
Vector elements:'; for (int i = 0; i < myvec.size(); i++) cout << myvec[i] << ' '; // remove the first element myvec.erase(myvec.begin()); cout<<'
Vector size after erase: '< Ausgabe:
Vektorelemente: 1 1 2 3 5
Vektorgröße nach dem Löschen: 4
Vektor nach Löschvorgang: 1 2 3 5
Wie in der obigen Ausgabe für die Größenänderungsfunktion gezeigt, geben wir den Bereich oder die Position des Elements an, das gelöscht oder entfernt werden soll. Im obigen Beispiel haben wir die Position angegeben, die auf das erste Element im Vektor zeigt.
Elemente in den Vektor einfügen
Die Vektorklasse std :: vector bietet eine weitere Funktion zum Einfügen von Werten in den Vektor. Mit der Einfügefunktion können wir Elemente vor der angegebenen Position in den Vektor einfügen.
Dies wird anhand des folgenden Beispiels deutlich.
#include #include using namespace std; int main() { // Assign vector vector myvec = {2,3,4}; cout << '
Initial vector: '; for (int i = 0; i < myvec.size(); i++) cout << myvec[i] << ' '; // inserts 20 at the beginning, 30 after that myvec.insert(myvec.begin(), 20); myvec.insert(myvec.begin()+1,30); cout << '
New vector after insert: '; for (int i = 0; i < myvec.size(); i++) cout << myvec[i] << ' '; }
Ausgabe:
Anfangsvektor: 2 3 4
Neuer Vektor nach dem Einfügen: 20 30 2 3 4
Das obige Programm deklariert zunächst einen Vektor mit 3 Elementen. Dann rufen wir die Einfügefunktion zweimal auf, um die Werte 20 und 30 an der ersten bzw. zweiten Position im Vektor einzufügen. Dann zeigen wir den geänderten Vektor an.
Vektorinhalt austauschen
Die Vektorklasse bietet uns auch die Möglichkeit, den Inhalt eines Vektors mit dem eines anderen Vektors des gleichen Typs und der gleichen Größe auszutauschen oder auszutauschen. Dies wird durch die in den Vektor integrierte Funktion „Swap“ erreicht.
Betrachten Sie den folgenden Code.
#include #include using namespace std; int main() { // swap operation vector v1, v2; v1.push_back(1); v1.push_back(3); v2.push_back(5); v2.push_back(7); cout << '
Vector 1: '; for (int i = 0; i < v1.size(); i++) cout << v1[i] << ' '; cout << '
Vector 2: '; for (int i = 0; i < v2.size(); i++) cout << v2[i] << ' '; // Swaps v1 and v2 v1.swap(v2); cout << '
After Swap
Vector 1: '; for (int i = 0; i < v1.size(); i++) cout << v1[i] << ' '; cout << '
Vector 2: '; for (int i = 0; i < v2.size(); i++) cout << v2[i] << ' '; }
Ausgabe:
Vektor 1: 1 3
Vektor 2: 5 7
Nach dem Tausch
Vektor 1: 5 7
Vektor 2: 1 3
Der obige Code zeigt den Inhalt von zwei Vektoren vor und nach dem Austauschen.
Werte im Vektor löschen
Im Gegensatz zum Entfernen eines oder mehrerer Elemente aus dem Vektor mithilfe der Löschfunktion haben wir eine andere Funktion 'Löschen', mit der wir alle Elemente im Vektorcontainer entfernen können.
Im folgenden Programm zeigen wir eine klare Funktion des Vektorcontainers.
#include #include using namespace std; int main() { // swap operation vector v1; v1.push_back(1); v1.push_back(3); v1.push_back(5); v1.push_back(7); cout<<'
Size of vector v1: '< Ausgabe:
Größe des Vektors v1: 4
Vektor 1: 1 3 5 7
Größe des Vektors v1 nach Aufruf der Löschfunktion: 0
Hier deklarieren wir zuerst einen Vektor und schieben dann Elemente hinein. Sobald wir die Funktion clear () aufrufen, sehen wir, dass alle Elemente im Vektor auf einmal entfernt werden.
bei (pos)
Diese Funktion gibt den Verweis auf das Element an der Position 'pos' innerhalb des Vektors zurück.
Dies ist eine der Funktionen, mit denen auf das Vektorelement zugegriffen wird.
Ein Beispiel ist unten angegeben:
#include #include using namespace std; int main() { // Assign vector vector myvec = {1,1,2,3,5,8}; cout<<'
Element at position 3 : '< Ausgabe:
Element an Position 3: 3
Wie im Beispiel gezeigt, wird die Funktion 'at' verwendet, um an der angegebenen Position auf das Element im Vektor zuzugreifen.
Vorderseite
Die Funktion 'front' gibt den Verweis auf das erste Element des Vektors zurück. Dies ist eine weitere Funktion, mit der wir auf die Elemente des Vektorcontainers zugreifen.
Das folgende Beispiel zeigt die Verwendung der Frontfunktion.
#include #include #include using namespace std; int main() { // Initialize vector vector myvec = {1,1,2,3,5,8}; cout<<'
Input vector: '; for(auto it=myvec.begin();it Ausgabe:
Eingabevektor: 1 1 2 3 5 8
Element an der Vorderseite des Vektors: 1
Zurück
Ähnlich wie bei der Funktion 'Front' wird mit der Funktion 'Back' auf das letzte Element des Vektorcontainers zugegriffen. Die Funktion 'Zurück' gibt einen Verweis auf das letzte Element im Vektorcontainer zurück.
Das folgende Beispiel zeigt die Verwendung der Funktion 'Zurück'.
#include #include #include using namespace std; int main() { // Initialize vector vector myvec = {1,1,2,3,5,8}; cout<<'
Input vector: '; for(auto it=myvec.begin();it Ausgabe:
Eingabevektor: 1 1 2 3 5 8
Element auf der Rückseite des Vektors: 8
Finden Sie ein Element im Vektor
Mit der Funktion 'Suchen' wird ermittelt, ob ein bestimmtes Element (als Schlüssel bezeichnet) im Vektor vorhanden ist oder nicht. Diese Funktion soll schnell und effizient sein. Sobald der Wert gefunden wurde, kehrt die Funktion zurück.
Das folgende Beispiel zeigt die Verwendung der Suchfunktion.
#include #include #include using namespace std; int main() { // Assign vector vector myvec = {1,1,2,3,5,8}; cout<<'
Input vector: '; for(auto it=myvec.begin();itkey; if(find(myvec.begin(),myvec.end(),key)!= myvec.end()) cout<<'
Element found'; else cout<<'
Element not found'; }
Ausgabe:
Eingabevektor: 1 1 2 3 5 8
Geben Sie den zu durchsuchenden Schlüssel ein: 0
Element nicht gefunden
2D-Vektor
Der zweidimensionale Vektor wird auch als 'Vektor des Vektors' bezeichnet. Genau wie zweidimensionale Arrays sind auch Elemente zweidimensionaler Vektoren in der Matrixform angeordnet.
Ein Beispielprogramm für einen 2D-Vektor ist unten angegeben.
#include #include // for 2D vector using namespace std; int main() { // Initializing 2D vector 'odd_vect' with vector odd_vect{ { 1, 3, 5 }, { 7, 9, 11 }, { 13,15,17 } }; // Displaying the 2D vector cout<<'2D vector : '; cout< Ausgabe:
2D-Vektor:
1 3 5
7 9 11
13 15 17
Beachten Sie im obigen Beispiel die Art und Weise, wie der 2D-Vektor definiert wird. Es ist als Vektor in einem anderen Vektor definiert. Bei der Anzeige dieses 2D-Vektors verwenden wir denselben Ansatz wie bei der Anzeige von 2D-Arrays.
Vektorbeispiel
Im Folgenden finden Sie ein Vektorbeispiel, das die meisten Vektoroperationen enthält.
Wie lade ich die vollständige Wiedergabeliste ohne Software von YouTube herunter?
#include #include using namespace std; int main() { // Assign vector vector myvec; // assign value 10 5 times myvec.assign(5, 10); cout << 'The vector elements: '; for (int i = 0; i < myvec.size(); i++) cout << myvec[i] << ' '; // push value 5 in myvec myvec.push_back(5); int n = myvec.size(); cout << '
The new vector after push_back:'; for (int i = 0; i < myvec.size(); i++) cout << myvec[i] << ' '; // pop the element myvec.pop_back(); cout<<'
New vector after pop_back : '; for (int i = 0; i < myvec.size(); i++) cout << myvec[i] << ' '; // inserts 20 at the beginning myvec.insert(myvec.begin(), 20); cout << '
New vector after insert: '; for (int i = 0; i < myvec.size(); i++) cout << myvec[i] << ' '; // remove the first element myvec.erase(myvec.begin()); cout<<'
Vector size after erase: '< Ausgabe:
Die Vektorelemente: 10 10 10 10 10
Der neue Vektor nach push_back: 10 10 10 10 10 5
Neuer Vektor nach pop_back: 10 10 10 10 10
Neuer Vektor nach dem Einfügen: 20 10 10 10 10 10
Vektorgröße nach dem Löschen: 5
Nach dem Löschen des ersten Elements: 10 10 10 10 10
Es folgt der Screenshot dafür.
Im obigen Beispiel deklarieren wir einen Vektor und geben dann mithilfe der Funktionen assign und push_back Elemente in den Vektor ein. Dann verwenden wir die Funktion pop_back, um ein Element vom Ende des Vektors zu entfernen. Danach fügen wir dem Vektor erneut ein Element mit dem Einfügeelement hinzu und löschen das Element dann mit der Löschfunktion.
Dies ist ein End-to-End-Beispiel für den Vektorcontainer, der seine verschiedenen Funktionen demonstriert.
Fazit
Damit sind wir am Ende dieses Tutorials zum Thema Vektor angelangt.
In unserem nächsten Tutorial lernen wir den 'Listen' -Container von STL kennen, der den Zeilen von Arrays und Vektoren ähnelt.
=> Lesen Sie hier den perfekten C ++ - Schulungsleitfaden.
Literatur-Empfehlungen