Wie erweitern Sie einen Vektor in C++?

Wenn „expand“ hier bedeutet, dass mehr Elemente in den Vektor enthalten sind, damit seine Größe (Länge) zunimmt, kann ein Vektor erweitert werden. „Erweiterung eines Vektors“ ist jedoch kein klassischer Satz in C++. Tatsächlich bedeutet „Erweitern“ in C ++ tatsächlich den Namen eines Objekts durch die Werte seines Inhalts ersetzen.Wenn ein Vektor aus String -Literalen besteht, kann der Vektor durch eine Zeichenfolge ersetzt werden, die aus den String -Literalen besteht. Dies muss jedoch manuell erfolgen. Das heißt, es muss vom Programmierer und nicht von einer Bibliothek durchgeführt werden.

Ungeachtet dessen wird dieser Beitrag erklären, wie ein Vektor von Streichliteralen durch eine Reihe von Literalen ersetzt wird. Dieser Beitrag erklärt auch die unterschiedlichen Möglichkeiten, wie der C ++ - Vektor in Länge erhöht werden kann. Die Länge eines Vektors in C ++ wird als Größe bezeichnet.

Der Vektor hat Mitgliedsfunktionen. Seine Größe kann mit den Mitgliedern erhöht werden: Größe der Größe (), Insert (), emplace () und push_back (). In diesem Artikel werden die verschiedenen Möglichkeiten erläutert, wie der Vektor erweitert werden kann, dh erhöht in der Größe; und im Falle des Vektors von Streichliteralen, ersetzt durch alle String -Literale.

Führen Sie die Vektor -Codierung innerhalb des Haupt- () -Funktionskörpers durch, es sei denn. Vergessen Sie nicht, das Programm mit zu beginnen:

#enthalten
#enthalten
Verwenden von Namespace STD;

Artikelinhalt

• Saitenvektor zu einer Zeichenfolge
• Steigerung der Vektorgröße
• Größenänderung
• Einfügen
• Empace
• Push_back
• Kennen Sie die Länge eines Vektors
• Kapazität eines Vektors
• Rettungsraum für Vector
• Abschluss

Saitenvektor zu einer Zeichenfolge

Ein Vektor von String -Literalen kann durch eine Reihe der Literale ersetzt werden. Die Literale werden durch Kommas in der einen String getrennt. Der folgende Code zeigt dies:

vectorvtr = "Toyota", "Mitsubishi", "Ford", "Mercedes", "Jeep";
char arrchars [100];
int ctr = 0; //Schalter
int i = 0;
für (i = 0; iconst char* str = vtr [i];
int j = 0;
für (j = 0; str [j] != '\ 0'; J ++)
arrchars [ctr] = str [j];
++CTR;

arrchars [ctr] = ','; ++ ctr; arrchars [ctr] = ";
++CTR;

arrchars [ctr] = '\ 0';
Cout<Die Ausgabe ist:

Toyota, Mitsubishi, Ford, Mercedes, Jeep,

Welches ist eine lange Zeichenfolge. Eine Array -Zeichenfolge und ein String -Literal in doppelten Zitaten sind im Grunde dasselbe und enden in '\ 0'; Obwohl das Ende für das Doppelzitat String Literal implizit ist. Die letzte lange Zeichenfolge hat am Ende der Zeichensequenz nur eine '\ 0'. Der Code kann weiterhin geändert werden, um das letzte Komma und den letzten Platz zu entfernen.

Steigerung der Vektorgröße

Größenänderung

Die Member -Funktion der Größe () kann verwendet werden, um die Größe () eines Vektors zurückzugeben, wie der folgende Code zeigt:

vectorvtr 'f', 'g', 'h', 'i', 'j';
Cout<Der Ausgang ist 5.

void -Größenänderung (size_type sz)

Um die Größe eines Vektors zu erhöhen, sollte der Vektor auf eine größere Anzahl geändert werden. Der folgende Code verwendet dies mit der Mitgliederfunktion, der Größe (size_type sz):

vectorvtr 'f', 'g', 'h', 'i', 'j';
vtr.Größenänderung (7);
vtr [5] = 'k';
vtr [6] = 'l';
für (int i = 0; iCout<
Cout<Die Ausgabe ist:

F g h i j k l

Wenn ein Vektor gerade mit der Mitgliederfunktion der Größe der Größe () geändert wird, werden gegen Ende des Vektors neue leere Standorte zur Verfügung gestellt. Diese neuen Standorte können dann gefüllt werden.

void -Größe (size_type sz, const t & c)

Der gleiche Wert kann gegen Ende des Vektors zu den neuen Standorten mit dieser Überlastungsmethode der Größe () hinzugefügt werden. Illustration:

vectorvtr 'f', 'g', 'h', 'i', 'j';
vtr.Größenänderung (8, 'z');
für (int i = 0; iCout<
Cout<Die Ausgabe ist:

F g h i j z z z z z z z z z

Einfügen

Das Einsetzen findet vor dem Element statt, auf das der Iterator vermittelt wird.

Insert (const_iterator Position, const t & x)

Der folgende Code zeigt, wie diese Funktion verwendet wird:

vectorvtr 'f', 'g', 'h', 'i', 'j';
Vektor :: Iterator p = vtr.Start();
P ++, P ++;
char id = 'z';
vtr.Insert (p, id);
für (int i = 0; iCout<
Cout<Die Ausgabe ist:

F g z h i j

'Z' wurde vor H eingefügt. Die Funktion "start ()) gibt einen Iterator zurück, der auf das erste Element des Vektors verweist. Der Iterator kann dann in die gewünschte Position erhöht werden. Beachten Sie, dass das erwartete zweite Argument für Insert () hier eine Kennung ist.

Iterator Insert (const_iterator Position, T && x)

Der folgende Code zeigt, wie diese Funktion verwendet wird:

vectorvtr 'f', 'g', 'h', 'i', 'j';
Vektor :: Iterator p = vtr.Start();
P ++, P ++;
vtr.Insert (p, 'z');
für (int i = 0; iCout<
Cout<Die Ausgabe ist:

F g z h i j

'Z' wurde vor H eingefügt. Die Funktion "start ()) gibt einen Iterator zurück, der auf das erste Element des Vektors verweist. Beachten Sie, dass das erwartete zweite Argument für Insert () hier buchstäblich ist.

Iterator Insert (const_iterator Position, size_type n, const t & x)

Der gleiche Wert kann mehr als einmal eingefügt werden. Der folgende Code zeigt dies:

vectorvtr 'f', 'g', 'h', 'i', 'j';
Vektor :: Iterator p = vtr.Start();
P ++, P ++;
char id = 'z';
vtr.Insert (p, 3, id);
für (int i = 0; iCout<
Cout<Die Ausgabe ist:

F g z z z h i j

Iteratoreinsatz (const_iterator Position, InputIterator zuerst, InputIterator zuletzt)

Ein Bereich von einem anderen Vektor kann eingefügt werden. Der folgende Code zeigt dies:

vector othervtr = 'k', 'l', 'm', 'n', 'o';
Vektor :: Iterator i = othervtr.Start();
i = i + 1;
Vektor :: Iterator j = othervtr.Ende();
J = J - 2;
vectorvtr 'f', 'g', 'h', 'i', 'j';
Vektor :: Iterator p = vtr.Start();
P ++, P ++;
vtr.Insert (p, i, j);
für (int i = 0; iCout<
Cout<Die Ausgabe ist:

F g l m h i j

Für den anderen Vektor wird der Bereich wie folgt erhalten: Die Funktion mit Beginn () gibt einen Iterator zurück, der auf sein erstes Element verweist. Dieser Iterator war inkrementiert, um auf das nächste Element zu verweisen. Die Member -Funktion von End () gibt einen Iterator zurück, der kurz nach dem letzten Element zeigt. Dieser Iterator, J wurde zweimal durch Subtrahieren von 2 von ihm abgeschlossen, und er wies dann auf das Element 'n' hin, der auf das Element hingewiesen wurde.

Zu diesem Zeitpunkt ist der imaginäre Bereich:

'L', 'm', 'n'

Bei C ++ wird jedoch das letzte Element in einem Bereich nicht beteiligt (eingefügt). Also wird nur "'l', 'm'" eingefügt.

Iteratoreinsatz (const_iterator Position, Initializer_List il)

Eine Vektorliteralliste kann eingefügt werden. Der folgende Code zeigt dies:

vectorvtr 'f', 'g', 'h', 'i', 'j';
Vektor :: Iterator p = vtr.Start();
P ++, P ++;
vtr.insert (p, 'k', 'l', 'm', 'n', 'o');
für (int i = 0; iCout<
Cout<Die Ausgabe ist:

F g k l m n o h i j

Empace

Die Verwendung von emplace () ähnelt der Verwendung von Insert (), und viele Programmierer bevorzugen es dem Insert ().

Im Inneren

Für den folgenden Code wird 'z' innerhalb der Werte 'f', 'g', 'h', 'i', 'J' aufgenommen:

vectorvtr 'f', 'g', 'h', 'i', 'j';
Vektor :: Iterator p = vtr.Start();
P ++, P ++;
vtr.Emplace (p, 'z');
für (int i = 0; iCout<
Cout<Die Ausgabe ist:

Vor Ort

Für den folgenden Code wird 'Z' vor den Werten 'f', 'g', 'H', 'I', 'J' aufgenommen:

vectorvtr 'f', 'g', 'h', 'i', 'j';
Vektor :: Iterator p = vtr.Start();
vtr.Emplace (p, 'z');
für (int i = 0; iCout<
Cout<Der Iterator, der von begin () zurückgegeben wurde, wurde nicht inkrementiert; Und so ist die Ausgabe:

Z f g h i j

Push_back

Mit der Member -Funktion push_back () kann ein Element angehängt werden. Der folgende Code zeigt dies:

vectorvtr 'f', 'g', 'h', 'i', 'j';
vtr.push_back ('z');
für (int i = 0; iCout<
Cout<Die Ausgabe ist:

F g h i j z

Ein Element kann auch mit der Member -Funktion emplaPla-_back () angehängt werden. Der folgende Code zeigt dies:

vectorvtr 'f', 'g', 'h', 'i', 'j';
vtr.emplace_back ('z');
für (int i = 0; iCout<
Cout<Die Ausgabe ist:

F g h i j z

Kennen Sie die Länge eines Vektors

Die Größe eines Vektors bedeutet die Anzahl der Elemente im Vektor. Dies kann unter Verwendung der Member -Funktion der Größe () erhalten werden. Das folgende Programm zeigt dies:

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

vectorvtr = 'f', 'g', 'h', 'i', 'j', 'k';
int sz = vtr.Größe();
Cout<Rückkehr 0;

Die Ausgabe ist 6.

Kapazität eines Vektors

Die Kapazität eines Vektors sollte nicht mit der Größe des Vektors verwechselt werden. Wenn ein Vektor manipuliert und erhöht wird, werden die Orte seiner Elemente im Speicher des Computers geändert (reallociert). Die Kapazität eines Vektors ist die Gesamtzahl der Elemente, die der Vektor halten kann, ohne dass eine Neuzuweisung erforderlich ist. Es wird mit der anfänglichen Größe des Vektors defen. Das folgende Programm zeigt dies für einen leeren Vektor und für einen Vektor von 5 Elementen:

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

Vektor VTR1;
Vektor vtr2 'f', 'g', 'h', 'i', 'j';
int Cap1 = vtr1.Kapazität();
int Cap2 = vtr2.Kapazität();
Cout<< cap1 <Cout<< cap2 <Rückkehr 0;

Die Ausgabe ist:

0
5

Rettungsraum für Vector

void Reserve (size_type n)

Der Vektorraum kann dieser Funktion reserviert werden. Das folgende Programm behält sich einen Platz von 5 Elementen vor:

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

vectorVtr = 'f', 'g', 'H';
vtr.Reserve (5);
int Cap = vtr.Kapazität();
Cout<< "New Capacity: " << cap <vtr.push_back ('i');
vtr.push_back ('j');
vtr.push_back ('k');
für (int i = 0; iCout<
Cout<Rückkehr 0;

Die Ausgabe ist:

Neue Kapazität: 5
F g h i j k k

Die reservierten Räume umfassen die für die ersten Elemente. Die Tatsache, dass 5 Leerzeichen reserviert waren, bedeutet nicht, dass ein Element nicht über 5 Elemente hinaus angehängt werden kann.

Abschluss

"Erweiterung eines Vektors" ist in C keine klassische Phrase++. Wenn jedoch „Erweiterung eines Vektors“ bedeutet, die Länge eines Vektors zu erhöhen, kann ein Vektor erweitert werden. In C ++ wird die Länge eines Vektors oder eines C ++ - Containers als Größe bezeichnet. Der Vektor kann mit den folgenden Mitgliedsfunktionen erweitert werden: Größe der Größe (), Insert (), Empla () und PUSP_BACK (). Andere verwandte Mitgliederfunktionen sind: Size (), Capaction () und Reserve (). In vielen C ++ - Programmen würde ein Vektor einige Male erhöht und verringert. Ein Vektor kann unter Verwendung der ERASE -Mitgliedsfunktion verringert werden - siehe später. Wenn ein Vektor aus String -Literalen besteht, kann der Vektor durch eine lange Zeichenfolge ersetzt werden, die aus den Streicherliteralen besteht.