C ++ emplace_back

Die C ++ Std :: Vector :: emplace_back () Methode erweitert den Vektor, indem ein neues Element hinzugefügt wird. Wenn zusätzlicher Platz erforderlich ist, findet eine Umverteilung statt. Wenn ein Gegenstand hinzugefügt oder zurückgezogen wird, können Vektoren die dynamischen Arrays ähnlich ändern, um die Größe automatisch zu ändern. Der Vektorspeicher wird automatisch vom Container behandelt. Außerdem kann man mit der Funktion emplapl_back () ein Element zum Ende eines Vektors hinzufügen, der dem bereits vorhanden ist, der bereits da ist. Diese Struktur existiert bereits. Lassen Sie uns einige Beispiele für die Methode emplace_back () erfassen.

Syntax des emplace_back () in c++

Die Deklaration für die Funktion STD :: Vector :: emplace_back () aus dem Std :: Vector Header ist in Folgendes bereitgestellt:

# Vektor.emplace_back (Element);

Der Parameter ist das Element, das dem Vektor hinzugefügt wird. Die Ergebnisse sind der Parameter, der am letzten Punkt in den Vektor eingefügt wird. Eine Ausnahme namens bad_alloc wird ausgestellt, wenn die Neuzuweisung fehlschlägt. Wenn eine Ausnahme ausgelöst wird, wird aufgrund der starken Ausnahmegarantie nichts geändert. Um zu vermeiden, dass ein Fehler geworfen wird, muss der Parameter den gleichen Typ wie der Container haben.

Beispiel 1:

Die Verwendung der Funktion emplace_back () wird im folgenden Beispiel demonstriert:

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

VectorVec;
vec.Emplace_back (1);
vec.Emplace_back (2);
vec.Emplace_back (3);
vec.emplace_back (4);
vec.Emplace_back (5);
für (auto it = vec.Start(); Es != VEC.Ende(); ++ es)
Cout<< " << *it;
Rückkehr 0;

Wir haben die Module für die Verwendung von Methoden und Klassen im Programm importiert. Beginnen Sie mit der Beispiel der Hauptfunktion. Wir haben ein Objekt als „VEC“ von Klassenvektoren mit dem Datentyp int erstellt. Anschließend haben wir mit jedem Vektorobjekt die Methode von emplaPlaPlback () aufgerufen und ein Vektorelement als Argument in der Methode emplace_back () eingefügt. Die „für“ -Schloop wird dann verwendet, um die Komponenten der Vektoren anzuzeigen. In der für Schleife haben wir ein automatisches Schlüsselwort mit der Variablen „IT“, die mit der Beginn -Methode festgelegt ist. Wir setzen ihre Variable auch mit der Endmethode fest. Dies iteriert das Vektorelement mit dem Inkrementoperator und gibt die Elemente in den Vektoren zurück, wie im folgenden Ausgangsbildschirm gezeigt:

Beispiel 2:

Wie im vorherigen Beispiel haben wir ein ganzzahliges Vektorbeispiel, das die Funktion emplaPla-_back () verwendet. Jetzt haben wir ein Beispiel für ein String -Vektor -Programm, um die Verwendung der EMPLACE () -Funktion zu demonstrieren.

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

VectorVector_Item;
vector_item.emplace_back ("Hallo");
vector_item.emplace_back ("my");
vector_item.emplace_back ("Geeks");
vector_item.emplace_back ("to");
vector_item.emplace_back ("emplace_back -Methode");
für (auto it = vector_item.Start(); Es != vector_item.Ende(); ++ es)
Cout<< " << *it;
Rückkehr 0;

Nach dem Einstellen des Namespace STD haben wir die Hauptmethode dieses bestimmten Programms erstellt. Im Inneren haben wir das Vektorklassenobjekt als "vector_item" festgelegt. Dann nannten wir dieses Objekt "vector_item" mit der Methode emplace_back () und die Vektorelemente als Argument eingefügt. Wir haben die Stringvektoren in die Methode emplace_back () eingefügt. Um diese Stringvektoren auf dem Konsolenbildschirm anzuzeigen. Sie können sehen, dass alle Vektorzeichenfolgen in der horizontalen Form erzeugt werden.

Beispiel 3:

Das Beispiel zum Demonstration des Zeichenvektors unter Verwendung der Funktion emplace_back ().

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

vectormyVec;
Myvec.emplace_back ('l');
Myvec.emplace_back ('i');
Myvec.emplace_back ('n');
Myvec.emplace_back ('u');
Myvec.emplace_back ('x');
für (auto it = myVec.Start(); Es != MyVec.Ende(); ++ es)
Cout<< " << *it;
Rückkehr 0;

Wir haben das Vektorobjekt als "myVec" erstellt. Dann haben wir mit dem Vektorobjekt "myVec" die Methode emplaPla-_back () bezeichnet. Wir geben jedes Mal die verschiedenen Zeichen an die Methode emplaPla-_back () ein. Die Schleife für die „für“ wird verwendet, um die Zeichenwerte aus der Methode emplace_back () zu drucken. Der folgende Bildschirm zeigt den Zeichenwert an, der von der Methode emplace_back () zurückgegeben wurde.

Beispiel 4:

Verwenden Sie die Funktion emplapl_back (), um die Ganzzahlen einem leeren Vektor hinzuzufügen und dann die Größe des resultierenden Vektors zu bestimmen. Dafür haben wir einen Algorithmus. Der Algorithmus ist, dass wir die Funktion emplace_back () verwenden müssen, um die Elemente dem Vektor hinzuzufügen. Überprüfen Sie dann, ob die Größe des Vektors 0 beträgt. Wenn nicht, packen Sie das hintere Element und erhöhen Sie die Zählervariable, die ursprünglich auf 0 initialisiert wurde. Sobald die Größe des Vektors auf 0 reduziert ist, wiederholen Sie diesen Vorgang. Zeigen Sie den Endwert der Variablen an.

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

int count = 0;
vectorv;
v.Emplace_back (1);
v.Emplace_back (2);
v.Emplace_back (3);
v.emplace_back (4);
während (!v.leer())
zählen ++;
v.Pop zurück();

Cout<< "count value:" ;
Cout<zurück 0;

Dort haben wir die Hauptmethode dieses Programms. Wir haben die variable "Anzahl", die mit dem Wert Null initialisiert wird. Dann haben wir ein Objekt "V" aus dem Klassenvektor. Wir haben die emplePlace_back () -Methode, durch die wir die Ganzzahlelemente eingefügt haben. Danach haben wir eine Weile Schleife, die den Zählwert druckt. Das Vektorelement darf nicht Null sein, damit die WHOP -Schleife wirksam ist. Dann wird die Anzahl durch die Methode pop_back () erhöht. Das Folgende ist ein Bildschirm, der den Zählwert anzeigt:

Beispiel 5:

Der push_back () wandelt eine Zeichenfolge in einen Vektor um. Ein neues String -Objekt wird zuerst implizit erzeugt und mit dem angegebenen Char* initialisiert und initialisiert. Die ursprüngliche Zeichenfolge ist ein temporäres Objekt, Push Back wird dann aufgerufen. Kopieren Sie diesen Zeichenfolge mit dem Konstruktor der Verschiebungsfunktion in den Vektor. Dann wird der vorübergehende Gegenstand zerstört. Andererseits baut der Emplace_back () die an Ort und Stelle an Ort und Stelle erstellt, es werden keine vorübergehenden Zeichenfolgen erstellt. Stattdessen wird emplaPly_back () direkt mit einem char* -Parameter aufgerufen. Dann erzeugt es eine Zeichenfolge, die im Vektor gespeichert ist, der mit diesem Zeichen initialisiert wurde. Auf diese Weise vermeiden wir es, ein sinnloses temporäres String -Objekt zu erstellen und zu entsorgen.

#enthalten
Verwenden von Namespace STD;
int main ()

Vektormy_Vect;
my_vect.emplace_back ('x', 12);
my_vect.push_back (make_pair ('y', 15));
für (int i = 0; iCout<<Rückkehr 0;

In der INT -Main erklärten wir, dass die vorrangige Vektor -Warteschlange als „my_Vect“ als Objekt deklariert wird,. Anschließend haben wir die emplePlace_back () -Methode, bei der die Paareingabe vorhanden ist. Danach haben wir die Paarwerte mit der Methode push_back () eingefügt. Beide Paarwerte aus der EMPLACE_BACK () und der push_back () werden mit Hilfe von A for Loop gedruckt. Die eingefügten Paarwerte werden in der folgenden Eingabeaufforderung ausgeführt:

Abschluss

Jetzt ist es Ihnen sehr klar++. Der Vorteil der Emplacing besteht darin. Welche wir verwenden, spielt keine Rolle für die primitiven Datentypen. Die Verwendung des EMPLACE () wird jedoch aufgrund ihrer Leistung für die Objekte empfohlen. Wir haben alle möglichen Beispielprogramme behandelt, um die Funktion emplace_back () zu erklären. Darüber hinaus unterschieden wir uns zwischen der Methode emplace_back () und der Methode push_back () mit dem Beispielprogramm.