So verwenden Sie C ++ - Vektor

Ein Array ist eine Reihe vonselben Objekttypen an aufeinanderfolgenden Speicherorten. Ein Array kann die Erz nicht erhöhen, die Länge reduziert. Ein Vektor ist wie ein Array, aber seine Länge kann erhöht oder reduziert werden. Ein Vektor hat daher viel mehr Operationen als ein Array. C ++ hat viele Bibliotheken, die alle die C ++ - Standardbibliothek bilden. Eine dieser Bibliotheken ist die Containerbibliothek. Ein Container ist eine Sammlung von Objekten, und bestimmte Operationen können in der Sammlung ausgeführt werden. C ++ - Container können in zwei Sätze unterteilt werden: Sequenzbehälter und assoziative Container. Sequenzbehälter sind Vektor, Array (nicht das gleiche Array, das zuvor diskutiert wurde), Deque, ForeVe_List und List. Dies sind verschiedene Sammlungen (Array-ähnliche Datenstrukturen), und jedes bietet unterschiedliche Kompromisse mit. Jeder Programmierer sollte wissen, wie man entscheidet, ob man einen Vektor, ein Array, ein Deque, eine Vorwärtsliste oder eine Liste verwenden soll. Wenn ein Programmierer eine Struktur benötigt, die mehr Operationen als diejenigen erfordert, die mit einem gewöhnlichen Array verbunden sind, sollte das gewöhnliche Array nicht verwendet werden. Wenn die Aufgabe häufige Einfügungen und Löschungen in der Mitte der Sequenz umfasst, sollte eine Liste oder Vorwärtsliste verwendet werden. Wenn die Aufgabe am Anfang oder am Ende einer Sequenz häufige Einfügungen und Löschungen umfasst, sollte ein Deque verwendet werden. Ein Vektor sollte verwendet werden, wenn diese Art von Operationen nicht erforderlich sind. Dieser Artikel zeigt Ihnen, wie Sie den C ++ - Vektor verwenden. Sie benötigen einige Kenntnisse über C ++ - Hinweise, Referenzen und Arrays, um diesen Artikel zu verstehen.

Klasse und Objekte

Eine Klasse ist eine Reihe von Variablen und Funktionen, die zusammenarbeiten, wobei die Variablen keine Werte zugewiesen haben. Wenn der Variablen Werte zugewiesen werden, wird eine Klasse zu einem Objekt. Verschiedene Werte, die derselben Klasse angegeben werden, führen zu verschiedenen Objekten. Das heißt, verschiedene Objekte können derselben Klasse haben, haben jedoch unterschiedliche Werte. Das Erstellen eines Objekts aus einer Klasse wird auch als Instanzipen des Objekts bezeichnet.

Der Begriff Vektor beschreibt eine Klasse. Ein aus einem Vektor erstellter Objekt hat einen Namen, der vom Programmierer ausgewählt wird.

Eine Funktion, die zu einer Klasse gehört, ist erforderlich, um ein Objekt aus der Klasse zu instanziieren. In C ++ hat diese Funktion den gleichen Namen wie der Name der Klasse. Verschiedene Objekte, die aus der Klasse erstellt (instanziiert) wurden.

Das Erstellen eines Objekts aus einer Klasse bedeutet, das Objekt zu konstruieren. Es bedeutet auch, das Objekt zu instanziieren.

Die Vektorklasse

Die Vektorklasse wurde bereits definiert und befindet sich in der Bibliothek. Um die Vektorklasse zu verwenden, muss ein Programmierer den Vektorheader in die Datei mit der folgenden Vorverarbeitungsrichtlinie aufnehmen:

#enthalten

Sobald der Header enthalten ist, werden alle Vektorfunktionen (Datenmitglieder und Mitgliederfunktionen) zugänglich. Um das Zählobjekt zum Ausgabe von Daten an der Terminal (Konsole) auszugeben, muss auch der Objektheader enthalten sein. Um ein Programm mit dem Vektor zu schreiben, müssen die folgenden Header mindestens enthalten sein:

#enthalten
#enthalten

Instanzipieren eines Vektors

int foo [10];

Oben ist die Erklärung eines Arrays mit dem Namen „Foo“ und der Anzahl der Elemente „10.Dies ist eine Reihe von ganzen Zahlen. Die Erklärung eines Vektors ist ähnlich. Für einen Vektor ist die Anzahl der Elemente optional, da die Vektorlänge zunehmen oder verringern kann.

Zu diesem Zeitpunkt im Programm wurde die Vektorklasse bereits in der Bibliothek definiert, und der Header wurde enthalten. Der Vektor kann wie folgt instanziiert werden:

STD :: Vektor vtr (8);

Hier ist der Vektor der speziellen Konstruktorfunktion. Die Art der Daten, die der Vektor enthält, ist „int“ in Winkelklammern. Der Begriff „VTR“ ist der Name, der vom Programmierer für den Vektor ausgewählt wurde. Schließlich ist „8“ in Klammern die vorläufige Anzahl von Ganzzahlen, die der Vektor haben wird.

Der Begriff „STD“ steht für den Standard -Namespace. In diesem Zusammenhang muss dieser Begriff von einem Doppeldarm folgen. Jeder kann seine eigene Bibliothek für Vektorklassen schreiben und sie verwenden. C ++ verfügt jedoch bereits über eine Standardbibliothek mit Standardnamen, einschließlich „Vektor.Um einen Standardnamen zu verwenden, muss der Standardname STD :: vorausgehen :: . Um das Eingeben von STD :: Jedes Mal im Programm für einen Standardnamen zu vermeiden, kann die Programmdatei wie folgt beginnen:

#enthalten
#enthalten
Verwenden von Namespace STD;

Überladen einer Funktion

Wenn zwei oder mehr verschiedene Funktionssignaturen denselben Namen haben, soll dieser Name überlastet werden. Wenn eine Funktion aufgerufen wird, bestimmen die Anzahl und Art der Argumente, welche Funktion ausgeführt wird.

Erstellung eines Vektors

Das Erstellen eines Vektors bedeutet das Instanziieren (Erstellen) eines Vektorobjekts. Die Konstruktorfunktion wird wie folgt überladen:

Vektorname

Dies erzeugt einen Vektor mit Länge Null und Typ „t“.Die folgende Anweisung erstellt einen Vektor mit Nulllänge des Typs "Float" mit dem Namen "VTR:"

Vektor vtr;

Vektorname (n)

Dies schafft einen Vektor mit N -Elementen vom Typ „t.Eine Erklärung für diesen Vektor mit vier Float -Elementen lautet wie folgt:

Vektor vtr (4);

Vektorname (n, t)

Dies schafft einen Vektor von N -Elementen, der auf den Wert t initialisiert wurde. Die folgende Aussage erstellt einen Vektor von 5 Elementen, wobei jedes Element den Wert 3 hat.4:

Vektor VTR (5, 3.4);

Konstruktion mit Initialisierung

Ein Vektor kann auf eine der folgenden zwei Arten konstruiert (erstellt) und gleichzeitig initialisiert werden:

Vektor vtr = 1.1, 2.2, 3.3, 4.4;

Oder

Vektor vtr 1.1, 2.2, 3.3, 4.4;

Beachten Sie, dass es keine Klammern direkt nach dem Objektnamen gibt. Klammern, die kurz nach dem Objektnamen verwendet werden, sollte wie folgt die Initialisierungsliste haben:

Vektor vtr (1.1, 2.2, 3.3, 4.4);

Ein Vektor kann später mit der Initializer -Liste konstruiert und initialisiert werden. In diesem Fall werden die Klammern nicht verwendet:

Vektor vtr;
vtr = 1.1, 2.2, 3.3, 4.4;

Vektor V2 (v1)

Dies ist ein Kopierkonstruktor. Es erstellt einen Vektor V2 als Kopie des Vektors V1. Der folgende Code zeigt dies:

Vektor VTR1 (5, 3.4);
Vektor vtr2 (vtr1);

Zuweisen eines Vektors während des Baus

Während des Baus kann ein leerer Vektor erstellt werden, während ein anderer wie folgt zugewiesen wird:

Vektor vtr1 1.1, 2.2, 3.3, 4.4;
Vektor vtr2 = vtr1;

Die zweite Aussage entspricht:

Vektor vtr2 = 1.1, 2.2, 3.3, 4.4;

Const Vector

Ein Const Vector ist ein Vektor, dessen Elemente nicht geändert werden können. Die Werte in diesem Vektor sind schreibgeschützt. Bei der Erstellung erscheint der Vektor wie folgt:

Const Vector vtr 1.1, 2.2, 3.3, 4.4;

In diesem Vektortyp kann kein Element hinzugefügt oder entfernt werden. Darüber hinaus kann kein Wert geändert werden.

Mit Iterator konstruieren

Eine Vorlage bietet eine generische Darstellung für einen Datentyp. Ein Iterator liefert eine generische Darstellung des Scannens durch die Werte eines Containers. Die Syntax, um einen Vektor mit einem Iterator zu erstellen, lautet wie folgt:

Vorlage
Vektor (InputIterator zuerst, InputIterator Last, Const Allocator & = Allocator ());

Dies erstellt einen Vektor für den Bereich [zuerst, zuletzt) ​​mit dem angegebenen Allocator, der später in diesem Artikel erörtert wird.

Einen Vektor zerstören

Einen Vektor zu zerstören, lassen.

Vektorkapazität

size_type capacity () const noexcept

Die Gesamtzahl der Elemente, die der Vektor ohne Neuzuweisung halten kann. Ein Codesegment dafür lautet wie folgt:

Vektor vtr (4);
int num = vtr.Kapazität();
Cout << num << '\n';

Die Ausgabe ist 4.

Reserve (n)

Speicherplatz ist nicht immer frei verfügbar. Zusätzlicher Platz kann im Voraus reserviert werden. Betrachten Sie das folgende Codesegment:

Vektor vtr (4);
vtr.Reserve (6);
Cout << vtr.capacity() << '\n';

Die Ausgabe ist 6. Der reservierte zusätzliche Raum beträgt 6 - 4 = 2 Elemente. Die Funktion gibt ungültig zurück.

size () const noexcept

Dies gibt die Anzahl der Elemente im Vektor zurück. Der folgende Code zeigt diese Funktion:

Vektor vtr (4);
float sz = vtr.Größe();
Cout << sz << '\n';

Die Ausgabe ist 4.

schrumpfen bis es passt()

Nachdem der Vektor einem Vektor mit der Funktion Reserve () eine zusätzliche Kapazität gegeben hat, kann der Vektor so hoch sind, dass er an seine ursprüngliche Größe passt. Der folgende Code zeigt dies:

Vektor vtr (4);
vtr.Reserve (6);
vtr.schrumpfen bis es passt();
int sz = vtr.Größe();
Cout << sz << '\n';

Die Ausgabe ist 4 und nicht 6. Die Funktion gibt ungültig zurück.

Größenänderung (SZ), Größenänderung (SZ, C)

Dies verändert den Vektor. Wenn die neue Größe kleiner als die alte Größe ist, werden die Elemente gegen Ende gelöscht. Wenn die neue Größe länger ist, wird gegen Ende ein Standardwert hinzugefügt. Verwenden Sie die Funktion "Größen () mit zwei Argumenten, um eine bestimmte Wertschöpfung hinzugefügt zu haben. Das folgende Codesegment zeigt die Verwendung dieser beiden Funktionen:

Vektor vtr1 1.1, 2.2, 3.3, 4.4;
vtr1.Größenänderung (2);
Cout << "New size of vtr1: " << vtr1.size() << '\n';
Vektor vtr2 1.1, 2.2;
VTR2.Größenänderung (4, 8.8);
Cout << "vtr2: "<< vtr2[0] <<" "<< vtr2[1] <<"
"<< vtr2[2] <<" "<< vtr2[3] << '\n';

Die Ausgabe ist Folgendes:

Neue Größe von VTR1: 2
VTR2: 1.1 2.2 8.8 8.8

Die Funktionen geben ungültig zurück.

leer () const noexcept

Diese Funktion gibt 1 für True zurück, wenn es keine Elemente im Vektor und 0 für False gibt, wenn der Vektor leer ist. Wenn ein Vektor 4 Stellen für eine bestimmte Art von Daten hat, z. B. Float ohne Schwimmerwert, ist dieser Vektor nicht leer. Der folgende Code zeigt dies:

Vektor vtr;
Cout << vtr.empty() << '\n';
Vektor VT (4);
Cout << vt.empty() << '\n';
Vektor V (4,3.5);
Cout << v.empty() << '\n';

Die Ausgabe ist Folgendes:

1
0
0

Vektorelementzugriff

Ein Vektor kann wie ein Array unter-skizziert (indiziert) werden. Die Indexzählung beginnt von Null.

Vectorname [i]

Die Operation „Vectorname [i]“ gibt einen Verweis auf das Element des i zurück^th Index des Vektors. Der folgende Code gibt 3 aus.3 Für den obigen Vektor:

Vektor vtr 1.1, 2.2, 3.3, 4.4;
float fl = vtr [2];
Cout << fl << '\n';

Vectorname [i] const

Die Operation "Vectorname [i] const" wird anstelle von "Vectorname [i]" ausgeführt, wenn der Vektor ein konstanter Vektor ist. Dieser Vorgang wird im folgenden Code verwendet:

Const Vector vtr 1.1, 2.2, 3.3, 4.4;
float fl = vtr [2];
Cout << fl << '\n';

Der Ausdruck gibt einen ständigen Hinweis auf das i zurück^th Vektorelement.

Zuweisen eines Wertes mit dem Index

Ein Wert kann einem nicht konstanten Vektor wie folgt zugeordnet werden:

Vektor vtr 1.1, 2.2, 3.3, 4.4;
VTR [2] = 8.8;
Cout << vtr[2] << '\n';

Die Ausgabe ist 8.8.

Vectorname.bei (i)

„Vectorname.bei (i) "ist wie" Vectorname [i] ", aber" Vectorname ".bei (i) “ist zuverlässiger. Der folgende Code zeigt, wie dieser Vektor verwendet werden soll:

Vektor vtr 1.1, 2.2, 3.3, 4.4;
float fl = vtr.um 2);
Cout << fl << '\n';
at () ist eine Vektorelementfunktion.

Vectorname.bei (i) const

„Vectorname.bei (i) const "ist wie" Vectorname [i] const ", aber" Vectorname ".bei (i) const ”ist zuverlässiger. „Vectorname.bei (i) const ”wird anstelle von„ vectorname.bei (i) “, wenn der Vektor ein konstanter Vektor ist. Dieser Vektor wird im folgenden Code verwendet:

Const Vector vtr 1.1, 2.2, 3.3, 4.4;
float fl = vtr.um 2);
Cout << fl << '\n';
at () const ist eine Vektorelementfunktion.

Zuweisen eines Wertes mit der Funktion AT ()

Ein Wert kann einem nicht konstanten Vektor mit der AT () -Funktion wie folgt zugeordnet werden:

Vektor vtr 1.1, 2.2, 3.3, 4.4;
vtr.bei (2) = 8.8;
Cout << vtr[2] << '\n';

Die Ausgabe ist 8.8.

Problem mit Sub-SCRIPTING

Das Problem bei der Unter-SKRIPTING (Indizierung) ist, dass, wenn der Index außerhalb des Bereichs liegt, Null zurückgegeben werden kann oder ein Fehler zur Laufzeit ausgegeben werden kann.

Vorderseite()

Dies gibt einen Verweis auf das erste Element des Vektors zurück, ohne das Element zu entfernen. Die Ausgabe des folgenden Codes beträgt 1.1.

Vektor vtr 1.1, 2.2, 3.3, 4.4;
float fl = vtr.Vorderseite();
Cout << fl << '\n';

Das Element wird nicht vom Vektor entfernt.

Front () const

Wenn der Vektorkonstruktion von const vorgegangen ist, wird der Ausdruck „Front () const“ anstelle von „Front () ausgeführt.Dies wird im folgenden Code verwendet:

Const Vector vtr 1.1, 2.2, 3.3, 4.4;
float fl = vtr.Vorderseite();
Cout << fl << '\n';

Eine konstante Referenz wird zurückgegeben. Das Element wird nicht vom Vektor entfernt.

zurück()

Dies gibt einen Verweis auf das letzte Element des Vektors zurück, ohne das Element zu entfernen. Die Ausgabe des folgenden Codes beträgt 4.4.

Vektor vtr 1.1, 2.2, 3.3, 4.4;
float fl = vtr.zurück();
Cout << fl << '\n';

back () const

Wenn der Vektorkonstruktion von const vorgegangen ist, wird der Ausdruck „Back () const“ anstelle von „zurück () ausgeführt ().Dies wird im folgenden Code verwendet:

Const Vector vtr 1.1, 2.2, 3.3, 4.4;
float fl = vtr.zurück();
Cout << fl << '\n';

Eine konstante Referenz wird zurückgegeben. Das Element wird nicht vom Vektor entfernt.

Vektordatenzugriff

Data () noexcept; Data () const noexcept;

Beide dieser gibt einen Zeiger so zurück, dass [data (), data () + size ()) ein gültiger Bereich ist.

Dies wird später im Artikel ausführlicher behandelt.

Rückkehrer Iteratoren und Vektor

Ein Iterator ist wie ein Zeiger, hat aber mehr Funktionen als ein Zeiger.

begin () noexcept

Gibt einen Iterator zurück, der auf das erste Element des Vektors verweist, wie im folgenden Codesegment:

Vektor vtr 1.1, 2.2, 3.3, 4.4;
Vektor:: iterator iter = vtr.Start();
Cout << *iter << '\n';

Der Ausgang ist 1.1. Beachten Sie, dass die Erklärung, die den Iterator empfängt, deklariert wurde. Der Iterator wird in einem Rückdruck der Rendite Derferenziert, um den Wert auf die gleiche Weise zu erhalten.

begin () const noexcept;

Gibt einen Iterator zurück, der auf das erste Element des Vektors verweist. Wenn der Vektorkonstruktion von const vorgegangen ist, wird der Ausdruck "begin () const" anstelle von "begin () ausgeführt.Unter dieser Bedingung kann das entsprechende Element im Vektor nicht geändert werden. Dies wird im folgenden Code verwendet:

Const Vector vtr 1.1, 2.2, 3.3, 4.4;
Vektor:: const_iterator iter = vtr.Start();
Cout << *iter << '\n';

Der Ausgang ist 1.1. Beachten Sie, dass "const_iterator" diesmal anstelle von "Iterator" verwendet wurde, um den zurückgegebenen Iterator zu empfangen.

end () noexcept

Gibt einen Iterator zurück, der unmittelbar über das letzte Element des Vektors hinweist. Betrachten Sie das folgende Codesegment:

Vektor vtr 1.1, 2.2, 3.3, 4.4;
Vektor:: iterator iter = vtr.Ende();
Cout << *iter << '\n';

Die Ausgabe ist 0, was bedeutungslos ist, da es kein konkretes Element über das letzte Element gibt.

End () const noexcept

Gibt einen Iterator zurück, der unmittelbar über das letzte Element des Vektors hinweist. Wenn der Vektorkonstruktion „const“ vorausgeht, wird der Ausdruck „End () const“ anstelle von „End () ausgeführt.Betrachten Sie das folgende Codesegment:

Const Vector vtr 1.1, 2.2, 3.3, 4.4;
Vektor:: const_iterator iter = vtr.Ende();
Cout << *iter << '\n';

Die Ausgabe ist 0. Beachten Sie, dass "const_iterator" diesmal anstelle von "Iterator" verwendet wurde, um den zurückgegebenen Iterator zu empfangen.

Reverse Iteration

Es ist möglich, einen Iterator zu haben, der von Ende bis kurz vor dem ersten Element iteriert.

rbegin () noexcept

Gibt einen Iterator zurück, der auf das letzte Element des Vektors verweist, wie im folgenden Codesegment:

Vektor vtr 1.1, 2.2, 3.3, 4.4;
Vektor:: Reverse_iterator Riter = vtr.rbegin ();
Cout << *rIter << '\n';

Die Ausgabe ist 4.4.

Beachten Sie, dass die Erklärung, die den umgekehrten Iterator empfängt, deklariert wurde. Der Iterator wird in einem Rückdruck der Rendite Derferenziert, um den Wert auf die gleiche Weise zu erhalten.

rbegin () const noexcept;

Gibt einen Iterator zurück, der auf das letzte Element des Vektors verweist. Wenn der Vektorkonstruktion „const“ vorausgeht, wird der Ausdruck „rBegin () const“ anstelle von „rBegin () ausgeführt.Unter dieser Bedingung kann das entsprechende Element im Vektor nicht geändert werden. Diese Funktion wird im folgenden Code verwendet:

Const Vector vtr 1.1, 2.2, 3.3, 4.4;
Vektor:: const_reverse_iterator riter = vtr.rbegin ();
Cout << *rIter << '\n';

Die Ausgabe ist 4.4.

Beachten Sie, dass diesmal der const_reverse_iterator verwendet wurde, anstatt nur den Reverse_iterator, um den zurückgegebenen Iterator zu empfangen.

rend () noexcept

Gibt einen Iterator zurück, der kurz vor dem ersten Element des Vektors zeigt. Betrachten Sie das folgende Codesegment:

Vektor vtr 1.1, 2.2, 3.3, 4.4;
Vektor:: Reverse_iterator Riter = vtr.zerreißen();
Cout << *rIter << '\n';

Die Ausgabe ist 0, was bedeutungslos ist, da es kurz vor dem ersten Element kein konkretes Element gibt.

rend () const noexcept

Gibt einen Iterator zurück, der kurz vor dem ersten Element des Vektors zeigt. Wenn der Vektorkonstruktion „const“ vorausgeht, wird der Ausdruck „rend () const“ anstelle von „rend () ausgeführt.Betrachten Sie das folgende Codesegment:

Const Vector vtr 1.1, 2.2, 3.3, 4.4;
Vektor:: const_reverse_iterator riter = vtr.zerreißen();
Cout << *rIter << '\n';

Die Ausgabe ist 0.

Beachten Sie, dass diesmal der const_reverse_iterator verwendet wurde, anstatt nur den Reverse_iterator, um den zurückgegebenen Iterator zu empfangen.

Vektormodifikatoren

Ein Modifikator, der den Vektor ändert.

A.Emplace (P, Args)

Fügt ein Objekt vom Typ t mit std :: vorwärts (args)… vor p ein.

Details - siehe später

Einfügen (Iteratorposition, Wert)

Fügt eine Kopie des Wertes an der Iteratorposition des Vektors ein. Gibt den Iterator (Position) im Vektor zurück, in dem die Kopie platziert wurde. Der folgende Code zeigt an, wo der Wert platziert wurde:

Vektor vtr 10, 20, 30, 40;
Vektor:: iterator iter = vtr.Start();
++Iter;
++Iter;
vtr.Insert (iter, 25);
Cout << vtr[1] << " << vtr[2]<< '
'' << vtr[3] << '\n';

Die Ausgabe ist: 20 25 30.

Beachten Sie, dass der Iterator genau wie ein Zeiger fortgeschritten (inkrementiert) wurde.

Eine Initialisierungsliste kann auch eingefügt werden, wie der folgende Code zeigt:

Vektor vtr 10, 20, 30, 40;
Vektor:: iterator iter = vtr.Start();
++Iter;
++Iter;
vtr.insert (iter, 25, 28);
Cout << vtr[1] << " << vtr[2]<< '
'' << vtr[3]<< " << vtr[4] << '\n';

Die Ausgabe ist: 20 25 28 30 30.

löschen (Position)

Entfernt ein Element an der vom Iterator gerichteten Position und gibt dann die Iteratorposition zurück. Der folgende Code zeigt dies:

Vektor vtr 10, 20, 30, 40;
Vektor:: iterator iter = vtr.Start();
++Iter;
++Iter;
vtr.löschen (iter);
Cout << vtr[0] << " << vtr[1] << '
'' << vtr[2]<< '\n';

Die Ausgabe ist: 10 20 40

push_back (t), push_back (RV)

Wird verwendet, um am Ende des Vektors ein einzelnes Element hinzuzufügen. Verwenden Sie wie folgt Push_back (T):

Vektor vtr 1.1, 2.2, 3.3, 4.4;
vtr.push_back (5.5);
float fl = vtr [4];
Cout << fl << '\n';

Der Ausgang ist 5.5.

push_back (RV): - Siehe später.

Pop zurück()

Entfernt das letzte Element, ohne es zurückzugeben. Die Größe des Vektors wird um 1 reduziert. Der folgende Code zeigt dies:

Vektor vtr 1.1, 2.2, 3.3, 4.4;
vtr.Pop zurück();
float sz = vtr.Größe();
Cout << sz << '\n';

Die Ausgabe ist 3.

A.Tausch (b)

Zwei Vektoren können ausgetauscht werden, wie im folgenden Codesegment dargestellt:

Vektor vtr1 1.1, 2.2, 3.3, 4.4;
Vektor vtr2 10, 20;
vtr1.Swap (vtr2);
Cout << "vtr1: "<< vtr1[0] <<" "<< vtr1[1] <<"
"<< vtr1[2] <<" "<< vtr1[3] << '\n';
Cout << "vtr2: "<< vtr2[0] <<" "<< vtr2[1] <<"
"<< vtr2[2] <<" "<< vtr2[3] << '\n';

Die Ausgabe ist:

VTR1: 10 20 0 0
VTR2: 1.1 2.2 3.3 4.4

Beachten Sie, dass die Länge eines Vektors bei Bedarf erhöht wird. Auch Werte, die nicht ersetzt wurden, werden durch einen Standardwert ersetzt.

klar()

Entfernt alle Elemente aus dem Vektor, wie das folgende Codesegment zeigt:

Vektor vtr 1.1, 2.2, 3.3, 4.4;
vtr.klar();
Cout << vtr.size() << '\n';

Die Ausgabe ist 0.

Gleichheit und relationale Operatoren für Vektoren

Der == Operator

Gibt 1 für True zurück, wenn die beiden Vektoren die gleiche Größe haben und die entsprechenden Elemente gleich sind; Ansonsten gibt es 0 für false zurück. Zum Beispiel:

Vektor U 1, 2, 3;
Vektor V 4, 5, 6;
bool bl = u == v;
Cout << bl << '\n';

Die Ausgabe ist 0.

Der != Operator

Gibt 1 für True zurück, wenn die beiden Vektoren nicht die gleiche Größe haben und/oder die entsprechenden Elemente nicht gleich sind; Ansonsten gibt es 0 für false zurück. Zum Beispiel:

Vektor U 1, 2, 3;
Vektor V 4, 5, 6;
bool bl = u!= V;
Cout << bl << '\n';

Der Ausgang ist 1.

Der < Operator

Gibt 1 für True zurück, wenn der erste Vektor die anfängliche Teilmenge des zweiten Vektors ist, wobei die Elemente der beiden gleichen Teile gleich und in derselben Reihenfolge sind. Wenn beide Vektoren gleich groß sind und sich von links nach rechts bewegen und ein Element im ersten Vektor auftritt, der im zweiten Vektor geringer ist als das entsprechende Element, wird 1 weiterhin zurückgegeben. Ansonsten wird 0 für False zurückgegeben. Zum Beispiel:

Vektor U 3, 1, 1;
Vektor V 3, 2, 1;
bool bl = uCout << bl << '\n';

Der Ausgang ist 1. < does not include the case when the size and order are the same.

Der> Operator

Kehrt zurück !(U < V), where U is the first vector and V is the second vector, according to the above definitions.

Der <= Operator

Gibt u zurück <= V, where U is the first vector and V is the second vector, according to the above definitions.

Der> = Operator

Kehrt zurück !(U <= V), where U is the first vector and V is the second vector, according to the above definitions.

Abschluss

Ein Vektor ist ein Beispiel für einen Sequenzbehälter. Ein Vektor ist eine „bessere“ Form des gewöhnlichen Arrays und wird von einer Klasse instanziiert. Vektoren haben Methoden, die unter: Konstruktion und Zuordnung, Kapazität, Elementzugriff, Datenzugriff, Iteratoren, Modifikatoren und numerische überlastete Operatoren eingestuft werden.

Es gibt andere Sequenzcontainer, die als Liste, Stürmer_List und Array bezeichnet werden. Wenn die Aufgabe häufige Einfügungen und Löschungen in der Mitte der Sequenz umfasst, sollte eine Liste oder Vorwärtsliste verwendet werden. Wenn die Aufgabe zu Beginn oder am Ende der Sequenz häufige Einfügungen und Löschungen beinhaltet, sollte ein Deque verwendet werden. Und so sollten Vektoren nur verwendet werden, wenn diese Art von Operationen nicht wichtig sind.