Verwendung von C++-Vektoren

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 mit 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 entscheidet, 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 die, die mit einem gewöhnlichen Array verbunden 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äufige Einfügungen und Löschungen 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.

Dieser Artikel zeigt Ihnen, 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 Namen, der vom Programmierer gewählt wird.

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:

#einschließen

Sobald der Header enthalten 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:

#einschließen
#einschließen

Instanziieren eines Vektors

int foo [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 im Programm wurde die Vektorklasse bereits in der Bibliothek definiert und der Header eingefügt. Der Vektor kann wie folgt instanziiert werden:

std::Vektor 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 Standard-Namensraum. Auf diesen Begriff muss in diesem Zusammenhang ein 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:

#einschließen
#einschließen
Verwenden von 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 (erstellen). Die Konstruktorfunktion wird wie folgt überladen:

Vektor Name

Dies erzeugt einen Vektor der Länge Null und Typ „T.” Die folgende Anweisung erzeugt einen Vektor der Länge Null vom Typ „float“ mit dem Namen „vtr:“

Vektor vtr;

Vektor Name (n)

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

Vektor vtr(4);

Vektor Name (n, t)

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

Vektor vtr (5, 3.4);

Konstruieren mit Initialisierung

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

Vektor vtr = 1.1, 2.2, 3.3, 4.4;

Oder

Vektor vtr1.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 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 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 vtr1(5, 3.4);
Vektor 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 vtr11.1, 2.2, 3.3, 4.4;
Vektor vtr2 = vtr1;

Die zweite Aussage ist äquivalent zu:

Vektor 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:

const-Vektor vtr1.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
vector(InputIterator zuerst, InputIterator zuletzt,const Allocator& = Allocator());

Dies konstruiert einen Vektor für den Bereich [erste, letzte) unter Verwendung des angegebenen Allocators, der später in diesem Artikel besprochen wird.

Einen Vektor zerstören

Um einen Vektor zu zerstören, lassen Sie ihn einfach aus dem Geltungsbereich gehen und die Zerstörung wird automatisch gehandhabt.

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ätselementfunktion zurückgegeben. Ein Codesegment dafür sieht wie folgt aus:

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ätzliche Plätze können 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 Platz 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 vtr(4);
Schwimmer sz = vtr.Größe();
cout << sz << '\n';

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 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 void zurück.

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

Dies ändert die Größe des Vektors. 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 vtr11.1, 2.2, 3.3, 4.4;
vtr1.Größe ändern (2);
cout << "New size of vtr1: " << vtr1.size() << '\n';
Vektor vtr21.1, 2.2;
vtr2.Größe ändern (4, 8.8);
cout << "vtr2: "<< vtr2[0] <<" "<< vtr2[1] <<"
"<< vtr2[2] <<" "<< vtr2[3] << '\n';

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 einen float-Wert, dann ist dieser Vektor nicht leer. Der folgende Code veranschaulicht 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 die folgende:

1
0
0

Zugriff auf Vektorelemente

Ein Vektor kann wie ein Array subscripted (indiziert) werden. Indexzählung beginnt bei Null.

Vektorname[i]

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

Vektor vtr1.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. Diese Operation wird im folgenden Code verwendet:

const-Vektor vtr1.1, 2.2, 3.3, 4.4;
float fl = vtr[2];
cout << fl << '\n';

Der Ausdruck gibt eine konstante Referenz auf das i . zurück^das Element des Vektors.

Wert mit tiefgestelltem Index zuweisen

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

Vektor vtr1.1, 2.2, 3.3, 4.4;
vtr[2] = 8.8;
cout << vtr[2] << '\n';

Die Ausgabe ist 8.8.

Vektorname.bei(i)

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

Vektor vtr1.1, 2.2, 3.3, 4.4;
Schwimmer fl = vtr.um 2);
cout << fl << '\n';
at() ist eine Vektorelementfunktion.

Vektorname.at(i) const

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

const-Vektor vtr1.1, 2.2, 3.3, 4.4;
Schwimmer fl = vtr.um 2);
cout << fl << '\n';
at() const ist eine Vektorelementfunktion.

Zuweisen eines Wertes mit der at()-Funktion

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

Vektor vtr1.1, 2.2, 3.3, 4.4;
vtr.at(2) = 8.8;
cout << vtr[2] << '\n';

Die Ausgabe ist 8.8.

Problem mit Subscripting

Das Problem bei der Subskription (Indexierung) besteht darin, dass, wenn der Index außerhalb des zulässigen Bereichs liegt, zur Laufzeit möglicherweise Null zurückgegeben oder 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 vtr1.1, 2.2, 3.3, 4.4;
Schwimmer fl = vtr.Vorderseite();
cout << fl << '\n';

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:

const-Vektor vtr1.1, 2.2, 3.3, 4.4;
Schwimmer fl = vtr.Vorderseite();
cout << fl << '\n';

Es wird eine konstante Referenz 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 vtr1.1, 2.2, 3.3, 4.4;
Schwimmer fl = vtr.zurück();
cout << fl << '\n';

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:

const-Vektor vtr1.1, 2.2, 3.3, 4.4;
Schwimmer fl = vtr.zurück();
cout << fl << '\n';

Es wird eine konstante Referenz 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 vtr1.1, 2.2, 3.3, 4.4;
Vektor::iterator iter = vtr.Start();
cout << *iter << '\n';

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:

const-Vektor vtr1.1, 2.2, 3.3, 4.4;
Vektor::const_iterator iter = vtr.Start();
cout << *iter << '\n';

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 vtr1.1, 2.2, 3.3, 4.4;
Vektor::iterator iter = vtr.Ende();
cout << *iter << '\n';

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:

const-Vektor vtr1.1, 2.2, 3.3, 4.4;
Vektor::const_iterator iter = vtr.Ende();
cout << *iter << '\n';

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 haben, 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 vtr1.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 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:

const-Vektor vtr1.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 anstelle des reverse_iterator verwendet wurde, um den zurückgegebenen Iterator zu erhalten.

rend() keine Ausnahme

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

Vektor vtr1.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 kein konkretes Element direkt vor dem ersten Element gibt.

rend() const keine Ausnahme

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

const-Vektor vtr1.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 anstelle des reverse_iterator verwendet wurde, um den zurückgegebenen Iterator zu erhalten.

Vektormodifikatoren

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

ein.einlagern(p, args)

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

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 vtr10, 20, 30, 40;
Vektor::iterator iter = vtr.Start();
++iter;
++iter;
vtr.einfügen (Iter, 25);
cout << vtr[1] << " << vtr[2]<< '
' << vtr[3] << '\n';

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 vtr10, 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.

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 vtr10, 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 ein einzelnes Element am Ende des Vektors hinzuzufügen. Verwenden Sie push_back(t) wie folgt:

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

Die Ausgabe 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 veranschaulicht dies:

Vektor vtr1.1, 2.2, 3.3, 4.4;
vtr.Pop zurück();
Schwimmer sz = vtr.Größe();
cout << sz << '\n';

Die Ausgabe ist 3.

ein.tauschen (b)

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

Vektor vtr11.1, 2.2, 3.3, 4.4;
Vektor vtr210, 20;
vtr1.tauschen (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. 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 vtr1.1, 2.2, 3.3, 4.4;
vtr.klar();
cout << vtr.size() << '\n';

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. Beispielsweise:

Vektor U1, 2, 3;
Vektor V4, 5, 6;
bool bl = U==V;
cout << bl << '\n';

Die Ausgabe ist 0.

Das != Betreiber

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. Beispielsweise:

Vektor U1, 2, 3;
Vektor V4, 5, 6;
bool bl = U!=V;
cout << bl << '\n';

Die Ausgabe ist 1.

Das < Operator

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 und in derselben Reihenfolge sind. 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. Beispielsweise:

Vektor U3, 1, 1;
Vektor V3, 2, 1;
bool bl = Ucout << bl << '\n';

Die Ausgabe ist 1. < does not include the case when the size and order are the same.

Der > Betreiber

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

Das <= Operator

Rückgabe U <= 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.

Fazit

Ein Vektor ist ein Beispiel für einen Sequenzcontainer. Ein Vektor ist eine „bessere“ Form des gewöhnlichen Arrays und wird aus 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, genannt list, forward_list und array. 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.