Verwendung von C++-Vektoren

How Use C Vector

Einführung

Ein Array ist eine Reihe von gleichen Objekttypen in aufeinanderfolgenden Speicherplätzen. Ein Array kann die Länge nicht vergrößern oder verkürzen. Ein Vektor ist wie ein Array, aber seine Länge kann vergrößert oder verkleinert 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 an der Sammlung ausgeführt werden. C++-Container können in zwei Gruppen gruppiert werden: Sequenzcontainer und assoziative Container. Sequenzcontainer sind vector, array (nicht das zuvor besprochene Array), deque, forward_list und list. Dies sind unterschiedliche Sammlungen (array-ähnliche Datenstrukturen) und jede bietet unterschiedliche Kompromisse.



Jeder Programmierer sollte wissen, wie er entscheiden kann, ob er einen Vektor, ein Array, ein Deque, eine forward_list oder eine Liste verwendet. Wenn ein Programmierer eine Struktur benötigt, die mehr Operationen erfordert, als einem gewöhnlichen Array zugeordnet sind, sollte das gewöhnliche Array nicht verwendet werden.



Wenn die Aufgabe häufiges Einfügen und Löschen in der Mitte der Sequenz beinhaltet, sollte eine Liste oder forward_list verwendet werden. Wenn die Aufgabe häufiges Einfügen und Löschen am Anfang oder Ende einer Sequenz beinhaltet, sollte ein Deque verwendet werden. Ein Vektor sollte verwendet werden, wenn diese Arten von Operationen nicht erforderlich sind.



In diesem Artikel erfahren Sie, wie Sie den C++-Vektor verwenden. Sie benötigen einige Kenntnisse über C++-Zeiger, -Referenzen und -Arrays, um diesen Artikel zu verstehen.

Klasse und Objekte

Eine Klasse ist ein Satz von Variablen und Funktionen, die zusammenarbeiten, wobei den Variablen keine Werte zugewiesen sind. Wenn den Variablen Werte zugewiesen werden, wird eine Klasse zu einem Objekt. Unterschiedliche Werte für dieselbe Klasse führen zu unterschiedlichen Objekten; das heißt, verschiedene Objekte können derselben Klasse angehören, aber unterschiedliche Werte haben. Das Erstellen eines Objekts aus einer Klasse wird auch als Instanziieren des Objekts bezeichnet.

Der Begriff Vektor beschreibt eine Klasse. Ein aus einem Vektor erstelltes Objekt hat einen vom Programmierer gewählten Namen.



Eine Funktion, die zu einer Klasse gehört, wird benötigt, um ein Objekt aus der Klasse zu instanziieren. In C++ hat diese Funktion denselben Namen wie der Name der Klasse. Verschiedene aus der Klasse erstellte (instanziierte) Objekte haben unterschiedliche Namen, die der Programmierer jedem von ihnen gegeben hat.

Ein Objekt aus einer Klasse zu erstellen 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 mit der folgenden Vorverarbeitungsanweisung in die Datei einfügen:

#enthalten

Sobald der Header eingeschlossen ist, werden alle Vektorfunktionen (Datenmember und Memberfunktionen) zugänglich. Um das Zählobjekt zur Ausgabe von Daten an das Terminal (Konsole) zu verwenden, muss auch der Objektkopf enthalten sein. Um ein Programm mit dem Vektor zu schreiben, müssen mindestens die folgenden Header enthalten sein:

#enthalten
#enthalten

Instanziieren eines Vektors

intfoo[10];

Oben ist die Deklaration eines Arrays mit dem Namen foo und der Anzahl der Elemente 10. Dies ist ein Array von ganzen Zahlen. Die Deklaration eines Vektors ist ähnlich. Bei einem Vektor ist die Anzahl der Elemente optional, da die Vektorlänge zunehmen oder abnehmen kann.

An dieser Stelle des Programms ist die Vektorklasse bereits in der Bibliothek definiert und der Header enthalten. Der Vektor kann wie folgt instanziiert werden:

std::Vektor <int>vtr(8);

Hier ist der Vektor von der speziellen Konstruktorfunktion. Der Datentyp, den der Vektor enthält, ist int in spitzen Klammern. Der Begriff vtr ist der vom Programmierer gewählte Name für den Vektor. Schließlich ist 8 in Klammern die vorläufige Anzahl von ganzen Zahlen, die der Vektor haben wird.

Der Begriff std steht für Standardnamensraum. In diesem Zusammenhang muss diesem Begriff ein doppelter Doppelpunkt folgen. Jeder kann seine eigene Vektorklassenbibliothek schreiben und verwenden. C++ verfügt jedoch bereits über eine Standardbibliothek mit Standardnamen, einschließlich Vektor. Um einen Standardnamen zu verwenden, muss dem Standardnamen std:: vorangestellt werden. Um die Eingabe von std:: jedes Mal im Programm für einen Standardnamen zu vermeiden, kann die Programmdatei wie folgt gestartet werden:

#enthalten
#enthalten
mit namespace std;

Überladen einer Funktion

Wenn zwei oder mehr verschiedene Funktionssignaturen denselben Namen haben, wird dieser Name als überladen bezeichnet. Beim Aufruf einer Funktion bestimmen Anzahl und Art der Argumente, welche Funktion ausgeführt wird.

Konstruieren eines Vektors

Einen Vektor zu konstruieren bedeutet, ein Vektorobjekt zu instanziieren (erzeugen). Die Konstruktorfunktion wird wie folgt überladen:

Vektorname

Dadurch wird ein Vektor der Länge Null vom Typ T erzeugt. Die folgende Anweisung erzeugt einen Vektor der Länge Null vom Typ float mit dem Namen vtr:

Vektor<schweben>vtr;

Vektorname (n)

Dadurch entsteht ein Vektor mit n Elementen vom Typ T. Eine Anweisung für diesen Vektor mit vier Float-Elementen lautet wie folgt:

Vektor<schweben>vtr(4);

Vektorname (n, t)

Dies erzeugt einen Vektor von n Elementen, der auf den Wert t initialisiert wird. Die folgende Anweisung erzeugt einen Vektor aus 5 Elementen, wobei jedes Element den Wert 3,4 hat:

Vektor<schweben>vtr(5, 3.4);

Konstruieren mit Initialisierung

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

Vektor<schweben>vtr= {1.1, 2.2, 3.3, 4.4};

Oder

Vektor<schweben>vtr{1.1, 2.2, 3.3, 4.4};

Beachten Sie, dass nach dem Objektnamen keine Klammern stehen. Klammern, die direkt nach dem Objektnamen verwendet werden, sollten die Initialisierungsliste wie folgt enthalten:

Vektor<schweben>vtr({1.1, 2.2, 3.3, 4.4});

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

Vektor<schweben>vtr;
vtr= {1.1, 2.2, 3.3, 4.4};

Vektor V2 (V1)

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

Vektor<schweben>vtr1(5, 3.4);
Vektor<schweben>vtr2(vtr1);

Zuweisen eines Vektors während der Konstruktion

Während der Konstruktion kann ein leerer Vektor erstellt werden, während ihm ein anderer zugewiesen wird, wie folgt:

Vektor<schweben>vtr1{1.1, 2.2, 3.3, 4.4};
Vektor<schweben>vtr2=vtr1;

Die zweite Aussage ist äquivalent zu:

Vektor<schweben>vtr2= {1.1, 2.2, 3.3, 4.4};

const Vektor

Ein konstanter Vektor ist ein Vektor, dessen Elemente nicht geändert werden können. Die Werte in diesem Vektor sind schreibgeschützt. Nach der Erstellung sieht der Vektor wie folgt aus:

constVektor<schweben>vtr{1.1, 2.2, 3.3, 4.4};

In diesem Vektortyp kann kein Element hinzugefügt oder entfernt werden. Außerdem kann kein Wert geändert werden.

Konstruieren mit Iterator

Eine Vorlage bietet eine generische Darstellung für einen Datentyp. Ein Iterator bietet eine generische Darstellung des Scannens durch die Werte eines Containers. Die Syntax zum Erstellen eines Vektors mit einem Iterator lautet wie folgt:

Vorlage<Klasse InputIterator>
Vektor(InputIterator zuerst,InputIterator zuletzt,constZuteiler& =Zuteiler());

Dadurch wird ein Vektor für den Bereich [erste, letzte) unter Verwendung des angegebenen Allocators erstellt, der später in diesem Artikel erläutert wird.

Einen Vektor zerstören

Um einen Vektor zu zerstören, lassen Sie ihn einfach den Gültigkeitsbereich verlassen und die Zerstörung wird automatisch ausgeführt.

Vektorkapazität

size_type capacity() const noexcept

Die Gesamtzahl der Elemente, die der Vektor aufnehmen kann, ohne dass eine Neuzuweisung erforderlich ist, wird von der Kapazitätsmitgliedsfunktion zurückgegeben. Ein Codesegment dafür sieht wie folgt aus:

Vektor<schweben>vtr(4);
intAuf eins=vtr.Kapazität();
Kosten<<Auf eins<< ' ';

Die Ausgabe ist 4.

Reserve(n)

Speicherplatz ist nicht immer frei verfügbar. Zusätzliche Plätze können im Voraus reserviert werden. Betrachten Sie das folgende Codesegment:

Vektor<schweben>vtr(4);
vtr.Reservieren(6);
Kosten<<vtr.Kapazität() << ' ';

Die Ausgabe ist 6. Der reservierte zusätzliche Speicherplatz beträgt also 6 – 4 = 2 Elemente. Die Funktion gibt void zurück.

size() const keine Ausnahme

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

Vektor<schweben>vtr(4);
schwebenS=vtr.Größe();
Kosten<<S<< ' ';

Die Ausgabe ist 4.

schrumpfen bis es passt()

Nachdem einem Vektor mit der Funktion reserve() zusätzliche Kapazität gegeben wurde, kann der Vektor auf seine ursprüngliche Größe verkleinert werden. Der folgende Code veranschaulicht dies:

Vektor<schweben>vtr(4);
vtr.Reservieren(6);
vtr.schrumpfen bis es passt();
intS=vtr.Größe();
Kosten<<S<< ' ';

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

Größe ändern (Größe), Größe ändern (Größe, c)

Dadurch wird die Größe des Vektors geändert. Ist die neue Größe kleiner als die alte Größe, werden die Elemente gegen Ende gelöscht. Wenn die neue Größe länger ist, wird gegen Ende ein Standardwert hinzugefügt. Um einen bestimmten Wert hinzuzufügen, verwenden Sie die Funktion resize() mit zwei Argumenten. Das folgende Codesegment veranschaulicht die Verwendung dieser beiden Funktionen:

Vektor<schweben>vtr1{1.1, 2.2, 3.3, 4.4};
vtr1.Größe ändern(2);
Kosten<< 'Neue Größe von vtr1: ' <<vtr1.Größe() << ' ';
Vektor<schweben>vtr2{1.1, 2.2};
vtr2.Größe ändern(4, 8.8);
Kosten<< 'vtr2:'<<vtr2[0] <<''<<vtr2[1] <<'
'
<<vtr2[2] <<''<<vtr2[3] << ' ';

Die Ausgabe ist die folgende:

Neue Größe von vtr1: 2
vtr2: 1,1 2,2 8,8 8,8

Die Funktionen geben void zurück.

empty() const noexcept

Diese Funktion gibt 1 für wahr zurück, wenn der Vektor keine Elemente enthält, und 0 für falsch, wenn der Vektor leer ist. Wenn ein Vektor 4 Positionen für einen bestimmten Datentyp hat, z. B. Float, ohne Float-Wert, ist dieser Vektor nicht leer. Der folgende Code veranschaulicht dies:

Vektor<schweben>vtr;
Kosten<<vtr.leer() << ' ';
Vektor<schweben>vt(4);
Kosten<<so dassleer() << ' ';

Vektor<schweben>v(4,3.5);
Kosten<<V.leer() << ' ';

Die Ausgabe ist die folgende:

1
0
0

Zugriff auf Vektorelemente

Ein Vektor kann wie ein Array mit einem Index versehen (indiziert) werden. Die Indexzählung beginnt bei Null.

Vektorname[i]

Die Operation vectorName[i] liefert eine Referenz auf das Element am iNSIndex des Vektors. Der folgende Code gibt 3.3 für den obigen Vektor aus:

Vektor<schweben>vtr{1.1, 2.2, 3.3, 4.4};
schwebenfl=vtr[2];
Kosten<<fl<< ' ';

vectorName[i] const

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

constVektor<schweben>vtr{1.1, 2.2, 3.3, 4.4};
schwebenfl=vtr[2];
Kosten<<fl<< ' ';

Der Ausdruck gibt eine konstante Referenz auf das i . zurückNSElement des Vektors.

Wert mit tiefgestelltem Index zuweisen

Einem nicht konstanten Vektor kann wie folgt ein Wert zugewiesen werden:

Vektor<schweben>vtr{1.1, 2.2, 3.3, 4.4};
vtr[2] = 8.8;
Kosten<<vtr[2] << ' ';

Die Ausgabe ist 8,8.

vectorName.at(i)

vectorName.at(i) ist wie vectorName[i], aber vectorName.at(i) ist zuverlässiger. Der folgende Code zeigt, wie dieser Vektor verwendet werden soll:

Vektor<schweben>vtr{1.1, 2.2, 3.3, 4.4};
schwebenfl=vtr.bei(2);
Kosten<<fl<< ' ';
bei()ist ein VektormitgliedFunktion.

vectorName.at(i) const

vectorName.at(i) const ist wie vectorName[i] const, aber vectorName.at(i) const ist zuverlässiger. vectorName.at(i) const wird anstelle von vectorName.at(i) ausgeführt, wenn der Vektor ein konstanter Vektor ist. Dieser Vektor wird im folgenden Code verwendet:

constVektor<schweben>vtr{1.1, 2.2, 3.3, 4.4};
schwebenfl=vtr.bei(2);
Kosten<<fl<< ' ';
bei() constist ein VektormitgliedFunktion.

Zuweisen eines Wertes mit der at()-Funktion

Mit der Funktion at() kann einem nicht konstanten Vektor ein Wert wie folgt zugewiesen werden:

Vektor<schweben>vtr{1.1, 2.2, 3.3, 4.4};
vtr.bei(2) = 8.8;
Kosten<<vtr[2] << ' ';

Die Ausgabe ist 8,8.

Problem mit Subskripting

Das Problem bei der Subskription (Indizierung) besteht darin, dass bei einem Index außerhalb des gültigen Bereichs möglicherweise Null zurückgegeben oder zur Laufzeit ein Fehler ausgegeben wird.

Vorderseite()

Dies gibt eine Referenz auf das erste Element des Vektors zurück, ohne das Element zu entfernen. Die Ausgabe des folgenden Codes ist 1.1.

Vektor<schweben>vtr{1.1, 2.2, 3.3, 4.4};
schwebenfl=vtr.Vorderseite();
Kosten<<fl<< ' ';

Das Element wird nicht aus dem Vektor entfernt.

front() const

Wenn der Vektorkonstruktion const vorangestellt ist, wird der Ausdruck front() const anstelle von front() ausgeführt. Dies wird im folgenden Code verwendet:

constVektor<schweben>vtr{1.1, 2.2, 3.3, 4.4};
schwebenfl=vtr.Vorderseite();
Kosten<<fl<< ' ';

Es wird ein konstanter Verweis zurückgegeben. Das Element wird nicht aus dem Vektor entfernt.

zurück()

Dies gibt eine Referenz auf das letzte Element des Vektors zurück, ohne das Element zu entfernen. Die Ausgabe des folgenden Codes ist 4.4.

Vektor<schweben>vtr{1.1, 2.2, 3.3, 4.4};
schwebenfl=vtr.zurück();
Kosten<<fl<< ' ';

zurück() const

Wenn der Vektorkonstruktion const vorangestellt ist, wird der Ausdruck back() const anstelle von back() ausgeführt. Dies wird im folgenden Code verwendet:

constVektor<schweben>vtr{1.1, 2.2, 3.3, 4.4};
schwebenfl=vtr.zurück();
Kosten<<fl<< ' ';

Es wird ein konstanter Verweis zurückgegeben. Das Element wird nicht aus dem Vektor entfernt.

Vektordatenzugriff

data() keine Ausnahme; data() const noaußer;

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

Dies wird später im Artikel genauer behandelt.

Zurückgebende Iteratoren und der Vektor

Ein Iterator ist wie ein Zeiger, hat aber mehr Funktionalität als ein Zeiger.

begin() keine Ausnahme

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

Vektor<schweben>vtr{1.1, 2.2, 3.3, 4.4};
Vektor<schweben> ::Iteratoriter=vtr.Start();
Kosten<< *iter<< ' ';

Die Ausgabe ist 1.1. Beachten Sie, dass die Deklaration, die den Iterator empfängt, deklariert wurde. Der Iterator wird in einem Rückgabeausdruck dereferenziert, um den Wert auf die gleiche Weise zu erhalten, wie ein Zeiger dereferenziert wird.

begin() const noexcept;

Gibt einen Iterator zurück, der auf das erste Element des Vektors zeigt. Wenn der Vektorkonstruktion const vorangestellt 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:

constVektor<schweben>vtr{1.1, 2.2, 3.3, 4.4};
Vektor<schweben> ::const_iteratoriter=vtr.Start();
Kosten<< *iter<< ' ';

Die Ausgabe ist 1.1. Beachten Sie, dass diesmal const_iterator anstelle von nur iterator verwendet wurde, um den zurückgegebenen Iterator zu erhalten.

end() keine Ausnahme

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

Vektor<schweben>vtr{1.1, 2.2, 3.3, 4.4};
Vektor<schweben> ::Iteratoriter=vtr.Ende();
Kosten<< *iter<< ' ';

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

end() const noexcept

Gibt einen Iterator zurück, der direkt über das letzte Element des Vektors hinaus zeigt. Wenn der Vektorkonstruktion const vorangestellt ist, wird der Ausdruck end() const anstelle von end() ausgeführt. Betrachten Sie das folgende Codesegment:

constVektor<schweben>vtr{1.1, 2.2, 3.3, 4.4};
Vektor<schweben> ::const_iteratoriter=vtr.Ende();
Kosten<< *iter<< ' ';

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

Umgekehrte Iteration

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

rbegin() keine Ausnahme

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

Vektor<schweben>vtr{1.1, 2.2, 3.3, 4.4};
Vektor<schweben> ::reverse_iteratorrIter=vtr.rbegin();
Kosten<< *rIter<< ' ';

Die Ausgabe ist 4.4.

Beachten Sie, dass die Deklaration, die den umgekehrten Iterator empfängt, deklariert wurde. Der Iterator wird in einem Rückgabeausdruck dereferenziert, um den Wert auf die gleiche Weise zu erhalten, wie ein Zeiger dereferenziert wird.

rbegin() const noaußer;

Gibt einen Iterator zurück, der auf das letzte Element des Vektors zeigt. Wenn der Vektorkonstruktion const vorangestellt ist, 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:

constVektor<schweben>vtr{1.1, 2.2, 3.3, 4.4};
Vektor<schweben> ::const_reverse_iteratorrIter=vtr.rbegin();
Kosten<< *rIter<< ' ';

Die Ausgabe ist 4.4.

Beachten Sie, dass diesmal der const_reverse_iterator anstelle des reverse_iterator verwendet wurde, um den zurückgegebenen Iterator zu empfangen.

render () keine Ausnahme

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

Vektor<schweben>vtr{1.1, 2.2, 3.3, 4.4};
Vektor<schweben> ::reverse_iteratorrIter=vtr.macht();
Kosten<< *rIter<< ' ';

Die Ausgabe ist 0, was bedeutungslos ist, da direkt vor dem ersten Element kein konkretes Element vorhanden ist.

render () const noexcept

Gibt einen Iterator zurück, der direkt vor dem ersten Element des Vektors zeigt. Wenn der Vektorkonstruktion const vorangestellt ist, wird statt rend() der Ausdruck rend() const ausgeführt. Betrachten Sie das folgende Codesegment:

constVektor<schweben>vtr{1.1, 2.2, 3.3, 4.4};
Vektor<schweben> ::const_reverse_iteratorrIter=vtr.macht();
Kosten<< *rIter<< ' ';

Die Ausgabe ist 0.

Beachten Sie, dass diesmal der const_reverse_iterator anstelle des reverse_iterator verwendet wurde, um den zurückgegebenen Iterator zu empfangen.

Vektormodifikatoren

Ein Modifikator, der den Vektor modifiziert, kann einen Iterator annehmen oder zurückgeben.

a.emplace(p, args)

Fügt ein Objekt vom Typ T ein, das mit std::forward(args)… vor p konstruiert wurde.

Für Details – siehe später

insert(iteratorPosition, Wert)

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

Vektor<int>vtr{10, zwanzig, 30, 40};
Vektor<int> ::Iteratoriter=vtr.Start();
++iter;
++iter;
vtr.Einfügung(iter, 25);
Kosten<<vtr[1] << '' <<vtr[2]<< '
'
<<vtr[3] << ' ';

Die Ausgabe ist: 20 25 30.

Beachten Sie, dass der Iterator wie ein Zeiger vorgerückt (inkrementiert) wurde.

Es kann auch eine Initialisierungsliste eingefügt werden, wie der folgende Code veranschaulicht:

Vektor<int>vtr{10, zwanzig, 30, 40};
Vektor<int> ::Iteratoriter=vtr.Start();
++iter;
++iter;
vtr.Einfügung(iter, {25, 28});

Kosten<<vtr[1] << '' <<vtr[2]<< '
'
<<vtr[3]<< '' <<vtr[4] << ' ';

Die Ausgabe ist: 20 25 28 30.

löschen(position)

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

Vektor<int>vtr{10, zwanzig, 30, 40};
Vektor<int> ::Iteratoriter=vtr.Start();
++iter;
++iter;
vtr.löschen(iter);
Kosten<<vtr[0] << '' <<vtr[1] << '
'
<<vtr[2]<< ' ';

Die Ausgabe ist: 10 20 40

push_back(t), push_back(rv)

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

Vektor<schweben>vtr{1.1, 2.2, 3.3, 4.4};
vtr.push_back(5.5);
schwebenfl=vtr[4];
Kosten<<fl<< ' ';

Die Ausgabe ist 5,5.

push_back(rv): -später sehen.

Pop zurück()

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

Vektor<schweben>vtr{1.1, 2.2, 3.3, 4.4};
vtr.Pop zurück();
schwebenS=vtr.Größe();
Kosten<<S<< ' ';

Die Ausgabe ist 3.

a.tauschen(b)

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

Vektor<schweben>vtr1{1.1, 2.2, 3.3, 4.4};
Vektor<schweben>vtr2{10, zwanzig};
vtr1.Tauschen(vtr2);
Kosten<< 'vtr1:'<<vtr1[0] <<''<<vtr1[1] <<'
'
<<vtr1[2] <<''<<vtr1[3] << ' ';

Kosten<< 'vtr2:'<<vtr2[0] <<''<<vtr2[1] <<'
'
<<vtr2[2] <<''<<vtr2[3] << ' ';

Die Ausgabe ist:

vtr1: 10 zwanzig 0 0
vtr2: 1.1 2.2 3.3 4.4

Beachten Sie, dass die Länge eines Vektors bei Bedarf erhöht wird. Außerdem werden Werte, die keine Ersetzungen hatten, durch einen Standardwert ersetzt.

klar()

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

Vektor<schweben>vtr{1.1, 2.2, 3.3, 4.4};
vtr.klar();
Kosten<<vtr.Größe() << ' ';

Die Ausgabe ist 0.

Gleichheits- und Beziehungsoperatoren für Vektoren

Der == Operator

Gibt 1 für wahr zurück, wenn die beiden Vektoren die gleiche Größe haben und die entsprechenden Elemente gleich sind; andernfalls wird 0 für false zurückgegeben. Zum Beispiel:

Vektor<int>U{1, 2, 3};
Vektor<int>V{4, 5, 6};
bool bl=U==V;
Kosten<<bl<< ' ';

Die Ausgabe ist 0.

Der != Operator

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

Vektor<int>U{1, 2, 3};
Vektor<int>V{4, 5, 6};
bool bl=U! =V;
Kosten<<bl<< ' ';

Die Ausgabe ist 1.

Die

Gibt 1 für wahr zurück, wenn der erste Vektor die anfängliche Teilmenge des zweiten Vektors ist, wobei die Elemente der beiden gleichen Teile gleich sind und in derselben Reihenfolge vorliegen. Wenn beide Vektoren die gleiche Größe haben und sich von links nach rechts bewegen und im ersten Vektor ein Element angetroffen wird, das kleiner ist als das entsprechende Element im zweiten Vektor, wird trotzdem 1 zurückgegeben. Andernfalls wird 0 für false zurückgegeben. Zum Beispiel:

Vektor<int>U{3, 1, 1};
Vektor<int>V{3, 2, 1};
bool bl=U<V;
Kosten<<bl<< ' ';

Die Ausgabe ist 1.

Der > Betreiber

Rückkehr! (U

Die<= Operator

Rückgabe U<= V, where U is the first vector and V is the second vector, according to the above definitions.

Der >= Operator

Rückkehr! (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 Sequenzcontainer. Ein Vektor ist eine bessere Form des gewöhnlichen Arrays und wird von einer Klasse instanziiert. Vektoren haben Methoden, die unterteilt werden in: Konstruktion und Zuweisung, Kapazität, Elementzugriff, Datenzugriff, Iteratoren, Modifikatoren und überladene numerische Operatoren.

Es gibt andere Sequenzcontainer, die list, forward_list und array genannt werden. Wenn die Aufgabe häufiges Einfügen und Löschen in der Mitte der Sequenz beinhaltet, sollte eine Liste oder forward_list verwendet werden. Wenn die Aufgabe häufige Einfügungen und Löschungen am Anfang oder Ende der Sequenz beinhaltet, sollte ein Deque verwendet werden. Daher sollten Vektoren nur verwendet werden, wenn diese Arten von Operationen nicht wichtig sind.