Nützlichste C ++ - Vektor -Mitgliedsfunktionen

C ++ - Vektor -Mitgliedsfunktionen können in die folgenden Kategorien gestellt werden: Konstruktion, Kapazität, Iteratoren, Elementzugriff und Modifikatoren. Jede dieser Kategorien hat viele Funktionen. Alle diese Funktionen werden in vielen Anwendungen nicht verwendet. Dieser Artikel erklärt das nützlichste dieser Funktionen. Mit Ausnahme der Kategorie der Modifikatoren werden in diesem Artikel nicht mehr als drei Funktionen für jede Kategorie erläutert. Die Kategorie der Modifikatoren kann in mehr Subkategorien unterteilt werden. In jeder dieser Unterkategorien werden nicht mehr als drei Funktionen erklärt. Wenn mehr als drei Funktionen für eine bestimmte Kategorie erklärt werden sollen, werden sie durch Illustration unterrichtet.

Ein Programm zur Verwendung von C ++ - Vektor sollte mit beginnen,

#enthalten
#enthalten

Artikelinhalt

• Konstruktion/Zerstörung
• Kapazität
• Iterator und Vektorzugriff
• Elementzugriff
• Zurückschieben und zurückschlagen
• Einfügen
• Zuweisen von Elementen (Ersatz)
• Löschen
• Klar
• Tauschen
• Abschluss

Konstruktion/Zerstörung

Die folgenden Codesegmente zeigen unterschiedliche Möglichkeiten, denselben Vektor zu erstellen:

Vektor 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);
Vektor vtr (3); // mit anfänglicher Anzahl von Elementen
VTR [0] = 5.5;
VTR [1] = 6.6;
VTR [2] = 7.7;
Vektor vtr (5, 0.0); //NEIN. Elemente: 5; Jeder Wert: 0.0
Vektor vtr 5.5, 6.6, 7.7, 8.8, 9.9; // Initialisierung
Vektor vtr = 5.5, 6.6, 7.7, 8.8, 9.9; // Konstruktion und Kopieren
Vektor vtr;
vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
Vektor vtr1 5.5, 6.6, 7.7, 8.8, 9.9;
Vektor vtr2 (vtr1);
Const Vector vtr = 5.5, 6.6, 7.7, 8.8, 9.9;

A Const Vector ist ein Vektor, dessen Elemente nicht geändert werden können. Die Werte sind schreibgeschützt.

Zerstörung

Um einen Vektor zu zerstören, lassen Sie ihn einfach aus dem Zielfernrohr gehen.

Kapazität

size () const noexcept

Die Anzahl der Elemente in einem Vektor wird von dieser Mitgliedsfunktion zurückgegeben. Mit dem folgenden Codesegment beträgt die Ausgabe 5:

Vektor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
float sz = vtr.Größe();
Cout << sz << '\n';
leer () const noexcept

Diese Methode gibt true zurück (1), wenn der Vektor kein Element und Falsch (0) hat, wenn der Vektor mindestens ein Element hat. Mit dem folgenden Code ist die Ausgabe 1 (für True):

Vektor vtr = ;
bool bl = vtr.leer();
Cout << bl << '\n';

Iterator und Vektorzugriff

Ein Iterator ist ein ausgefeilter Zeiger. Wenn der Vektor, vtr wurde erschaffen, vtr.Start() würde einen Iterator zurückgeben und auf das erste Element der Liste hinweisen. Es kann dann inkrementiert werden, um nach dem ersten, entsprechend auf die Elemente zuzugreifen.

Wenn der Vektor, vtr wurde erschaffen, vtr.Ende() würde einen Iterator zurückgeben und kurz nach dem letzten Element der Liste zeigen. Es kann dann dekrementiert werden, um auf das letzte Element und die Elemente vor dem letzten zuzugreifen, entsprechend. Das folgende Programm zeigt dies:

#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

Vektor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
Vektor:: iterator iterb = vtr.Start();
Iterb ++;
Vektor:: iterator itere = vtr.Ende();
itere--;
Cout << *iterB << ", " << *iterE << " << endl;
*iterb = 66.66; *itere = 99.99;
Cout << *iterB << ", " << *iterE << " << endl;
Rückkehr 0;

Die Ausgabe ist:

6.6, 9.9
66.66, 99.99

Die Werte zweier Elemente wurden von zwei Iteratoren zugegriffen, gelesen und geändert.

Elementzugriff

bei (i)

Dies ähnelt VTR [i] und es ist besser. Es kann verwendet werden, um den Wert eines Elements zu lesen oder zu ändern. Die Indexzählung beginnt von Null. Der Leser kann das folgende Programm testen:

#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

Vektor 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;
Rückkehr 0;

Die Ausgabe ist:

6.6, 9.9
66.66, 99.99

Die Werte zweier Elemente wurden durch Bezugnahme aufgerufen, gelesen und geändert.

Rückgabe des ersten Wertes

Der folgende Code gibt das erste Element zurück (kopiert):

Vektor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
float val = vtr.Vorderseite();
Cout << val << endl;

Der Ausgang ist 5.5. Die hier verwendete Mitgliedsfunktion ist: vorne ().

Rückgabe des letzten Wertes

Der folgende Code gibt das letzte Element zurück (kopiert):

Vektor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
float val = vtr.zurück();
Cout << val << endl;

Die Ausgabe ist 9.9. Die hier verwendete Mitgliedsfunktion ist: back ().

Zurückschieben und zurückschlagen

push_back ()

Ein Element kann an der Rückseite des Vektors angehängt werden. Der Wert kann buchstäblich sein oder durch den Kennung dargestellt werden. Der folgende Code zeigt dies:

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

Die ursprüngliche Liste lautet:

5.5, 6.6, 7.7, 8.8, 9.9

Die neue Liste lautet:

5.5, 6.6, 7.7, 8.8, 9.9, 10.1

Pop zurück()

Das letzte Element kann vom Vektor entfernt werden. Der folgende Code zeigt dies:

Vektor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vtr.Pop zurück();
für (int i = 0; iCout << vtr[i] << ", ";
Cout << endl;

Die ursprüngliche Liste lautet:

5.5, 6.6, 7.7, 8.8, 9.9

Die neue Liste lautet:

5.5, 6.6, 7.7, 8.8

Notiz: Der Vektor verfügt nicht über die Funktionen push_front () und pop_front ().

Einfügen

Einfügt vor dem Element, auf das der Iterator angezeigt wird.

Einfügen (p, e)

Dies fügt ein Element vor, bevor das Element vom Iterator, p, auf. e kann ein wörtlicher oder Kennung sein. Illustration:

float flt = 7.0;
Vektor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
Vektor:: iterator iterb = vtr.Start();
Iterb ++; Iterb ++;
vtr.Insert (iterb, flt);
für (int i = 0; iCout << vtr[i] << ", ";
Cout << endl;

Die ursprüngliche Liste lautet:

5.5, 6.6, 7.7, 8.8, 9.9

Die neue Liste lautet:

5.5, 6.6, 7, 7.7, 8.8, 9.9

Diese Einfügungsfunktion gibt einen Iterator (nicht codiert) zurück, der auf das eingefügte Element verweist.

Einfügen (p, il)

Eine Liste kann vor dem von dem Iterator gerichteten Element eingefügt werden. Illustration:

Vektor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
Vektor:: iterator iterb = vtr.Start();
iterb = iterb + 2;
vtr.einfügen (iterb, 7.1, 7.2, 7.3);
für (int i = 0; iCout << vtr[i] << ", ";
Cout << endl;

Die ursprüngliche Liste lautet:

5.5, 6.6, 7.7, 8.8, 9.9

Die neue Liste lautet:

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

Diese Einfügungsfunktion gibt einen Iterator (nicht codiert) zurück, der auf das erste eingefügte Element verweist.

Einfügen (p, n, t)

Fügt den gleichen Wert t, n -mal vor dem Element ein, auf das durch p gerichtet ist. Illustration:

Vektor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
Vektor:: iterator iterb = vtr.Start();
iterb = iterb + 2;
vtr.Einfügen (iterb, 3, 7.1);
für (int i = 0; iCout << vtr[i] << ", ";
Cout << endl;

Die ursprüngliche Liste lautet:

5.5, 6.6, 7.7, 8.8, 9.9

Die neue Liste lautet:

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

Diese Einfügungsfunktion gibt einen Iterator (nicht codiert) zurück, der auf das erste eingefügte Element verweist.

einfügen (p, i, j)

Ein Bereich kann von einem anderen Vektor kopiert und in den interessierenden Vektor eingefügt werden. Der folgende Code zeigt dies:

Vektor vtr1 = 7.1, 7.2, 7.3, 7.4, 7.5;
Vektor:: iterator iterb1 = vtr1.Start();
ITERB1 = ITERB1 + 1;
Vektor:: iterator itere1 = vtr1.Ende();
itere1 = itere1 - 2;
Vektor vtr2 = 5.5, 6.6, 7.7, 8.8, 9.9;
Vektor:: iterator iterb2 = vtr2.Start();
iterb2 = iterb2 + 2;
VTR2.Insert (iterb2, iterb1, itere1);
für (int i = 0; iCout << vtr2[i] << ", ";
Cout << endl;

Die ursprüngliche Liste für VTR2 lautet:

5.5, 6.6, 7.7, 8.8, 9.9

Die neue Liste für VTR2 lautet:

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

Der identifizierte Bereich, der kopiert wird, ist [7.2, 7.3, 7.4), angegeben als [i, j), was den letzten Wert bedeutet, 7.4 ist nicht enthalten.

Diese Einfügungsfunktion gibt einen Iterator (nicht codiert) zurück, der auf das erste eingefügte Element verweist.

Zuweisen von Elementen (Ersatz)

Zuweisen an Elemente bedeutet, die Elemente durch Kopien zu ersetzen. Alle Zuordnungsmitgliederfunktionen, geben Sie void zurück.

zuweisen (il)

Eine Liste kann alle Elemente im fraglichen Vektor ersetzen. Die Liste kann länger oder kürzer sein. Abbildung für kurze Liste:

Vektor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
Vektor:: iterator iterb = vtr.Start();
iterb = iterb + 2;
vtr.zuweisen (55).55, 66.66, 77.77);
für (int i = 0; iCout << vtr[i] << ", ";
Cout << endl;

Die ursprüngliche Liste lautet:

5.5, 6.6, 7.7, 8.8, 9.9

Die neue Liste lautet:

55.55, 66.66, 77.77

Illustration für längere Liste:

Vektor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
Vektor:: iterator iterb = vtr.Start();
iterb = iterb + 2;
vtr.zuweisen (55).55, 66.66, 77.77, 88.88, 99.99, 1010.1111);
für (int i = 0; iCout << vtr[i] << ", ";
Cout << endl;

Die ursprüngliche Liste lautet:

5.5, 6.6, 7.7, 8.8, 9.9

Die neue Liste lautet:

55.55, 66.66, 77.77, 88.88, 99.99, 1010.11

zuweisen (n, t)

Der gleiche Wert, der mehrere Male wiederholt hat, kann alle Elemente im betreffenden Vektor ersetzen. Die neue Liste kann länger oder kürzer sein. Abbildung für kurze Liste:

Vektor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
Vektor:: iterator iterb = vtr.Start();
iterb = iterb + 2;
vtr.zuweisen (2, 77.77);
für (int i = 0; iCout << vtr[i] << ", ";
Cout << endl;

Die ursprüngliche Liste lautet:

5.5, 6.6, 7.7, 8.8, 9.9

Die neue Liste lautet:

77.77, 77.77

zuweisen (i, j)

Ein Bereich kann von einem anderen Vektor kopiert und verwendet werden, um den gesamten Inhalt des interessierenden Vektors zu ersetzen. Der folgende Code zeigt dies:

Vektor vtr1 = 7.1, 7.2, 7.3, 7.4, 7.5;
Vektor:: iterator iterb1 = vtr1.Start();
ITERB1 = ITERB1 + 1;
Vektor:: iterator itere1 = vtr1.Ende();
itere1 = itere1 - 2;
Vektor vtr2 = 5.5, 6.6, 7.7, 8.8, 9.9;
Vektor:: iterator iterb2 = vtr2.Start();
iterb2 = iterb2 + 2;
VTR2.zuweisen (iterb1, itere1);
für (int i = 0; iCout << vtr2[i] << ", ";
Cout << endl;

Die ursprüngliche Liste für VTR2 lautet:

5.5, 6.6, 7.7, 8.8, 9.9

Die neue Liste für VTR2 lautet:

7.2, 7.3

Der identifizierte Bereich, der kopiert wird, ist [7.2, 7.3, 7.4), angegeben als [i, j), was den letzten Wert bedeutet, 7.4 ist nicht enthalten.

Löschen

Verwendet Iterator.

löschen (q)

Entfernt das Element, auf das durch Q hingewiesen wird, und verkürzt die Länge des Vektors. Gibt den Iterator zurück, der auf das nächste Element nach dem Entfernen zeigt. Beispiel:

Vektor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
Vektor:: iterator iterb = vtr.Start();
iterb = iterb + 2;
Vektor:: iterator itr = vtr.löschen (iterb);
für (int i = 0; iCout << vtr[i] << ", ";
Cout << endl;
Cout << *itR << endl;

Originalliste lautet:

5.5, 6.6, 7.7, 8.8, 9.9

Ausgabe ist:

5.5, 6.6, 8.8, 9.9,
8.8

löschen (Q1, Q2)

Entfernt eine Reihe von Elementen, die von dem von der Iterator q1 angezeigt werden, bis zu diesem, auf das durch Q2 hingewiesen wurde, jedoch ohne das von Q2 - dh es entfernt [Q1, Q2). Gibt den Iterator zurück, der auf das nächste Element zeigt, nachdem der Bereich entfernt wurde. Illustration:

Vektor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
Vektor:: iterator iterb = vtr.Start();
iterb = iterb + 2;
Vektor:: iterator itere = vtr.Ende();
itere = itere - 1;
Vektor:: iterator itr = vtr.löschen (iterb, itere);
für (int i = 0; iCout << vtr[i] << ", ";
Cout << endl;
Cout << *itR << endl;

Originalliste lautet:

5.5, 6.6, 7.7, 8.8, 9.9

Ausgabe ist:

5.5, 6.6, 9.9,
9.9

Klar

klar()

Gibt void zurück. Alle Elemente in einem Vektor können entfernt werden, wodurch die Länge des Vektors auf Null reduziert wird. Das ist wie:

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

Originalliste lautet:

5.5, 6.6, 7.7, 8.8, 9.9

Ausgabe ist:

0

Tauschen

X.Tausch (y)

Die Elemente von zwei verschiedenen Vektoren können unabhängig von ihren unterschiedlichen Längen getauscht werden. Illustration:

Vektor vtr1 = 1.1, 2.2, 3.3, 4.4;
Vektor vtr2 = 5.5, 6.6, 7.7, 8.8, 9.9;
VTR2.Swap (vtr1);
Cout << "New vtr1: ";
für (int i = 0; iCout << vtr1[i] << ", ";
Cout << endl;
Cout << "New vtr2: ";
für (int i = 0; iCout << vtr2[i] << ", ";
Cout << endl;

Ausgabe ist:

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

Abschluss

C ++ - Vektor hat viele Mitgliederfunktionen. Diese Funktionen können in den folgenden Unterkategorien kategorisiert werden: Konstruktion/Zerstörung, Kapazität, Iterator- und Vektorzugriff, Elementzugriff, Zurückdrücken und Pop -zurück, einfügen, Elemente (Ersatz), Löschen, Klar und Tausch. Die nützlichsten Funktionen in jedem dieser Unterkategorien wurden oben erklärt.