C ++ EMPlace_back

Il metodo C ++ std :: vector :: emplace_back () estende il vettore aggiungendo un nuovo elemento. Se è necessario uno spazio aggiuntivo, la riallocazione si svolge. Quando un articolo viene aggiunto o ritirato, i vettori hanno una capacità simile agli array dinamici di ridimensionare automaticamente. L'archiviazione vettoriale viene gestita automaticamente dal contenitore. Oltre a ciò, usando la funzione emplace_back (), si può aggiungere un elemento alla fine di un vettore, seguendo quello che è già lì. Questa struttura è già esistente. Andiamo avanti con alcuni esempi per cogliere di più sul metodo EMPlace_back ().

Sintassi di eMplace_back () in C++

La Dichiarazione per la funzione std :: vector :: emplace_back () dall'intestazione vettoriale di std :: è fornita nel seguente:

# vettore.emplace_back (elemento);

Il parametro è l'elemento che viene aggiunto al vettore. I risultati sono il parametro che viene inserito nel vettore all'ultimo punto. Un'eccezione chiamata BAD_ALLOC viene emessa se la riallocazione fallisce. Se viene lanciata un'eccezione, nulla viene cambiato a causa della forte garanzia di eccezione. Per evitare che venga lanciato un errore, il parametro deve essere dello stesso tipo del contenitore.

Esempio 1:

L'uso della funzione emplace_back () è dimostrato nel seguente esempio:

#includere
#includere
Utilizzo dello spazio dei nomi std;
int main ()

vectorvec;
Vec.emplace_back (1);
Vec.emplace_back (2);
Vec.emplace_back (3);
Vec.emplace_back (4);
Vec.emplace_back (5);
per (auto It = vec.inizio(); Esso != vec.FINE(); ++ esso)
cout<< " << *it;
restituzione 0;

Abbiamo importato i moduli per l'uso di metodi e classi nel programma. Inizia con l'esempio della funzione principale. Abbiamo creato un oggetto come "VEC" dei vettori di classe con il tipo di dati int. Quindi, abbiamo invocato il metodo EMPlace_back () con ciascun oggetto vettoriale e inserito un elemento vettoriale come argomento nel metodo EMPlace_back (). Il ciclo "per" viene quindi utilizzato per visualizzare i componenti dei vettori. Nel ciclo per, abbiamo una parola chiave automatica con la variabile "It" che è impostata con il metodo iniziale. Abbiamo anche impostato la sua variabile con il metodo di fine. Questo itera l'elemento vettoriale con l'operatore di incremento e restituisce gli elementi nei vettori come mostrato nella seguente schermata di uscita:

Esempio 2:

Come nell'esempio precedente, abbiamo un esempio di vettore intero che utilizza la funzione emplace_back (). Ora, abbiamo un esempio di un programma vettoriale di stringa per dimostrare l'uso della funzione EMPLETT ().

#includere
#includere
#includere
Utilizzo dello spazio dei nomi std;
int main ()

vectorvector_item;
vector_item.emplace_back ("ciao");
vector_item.emplace_back ("mio");
vector_item.emplace_back ("geeks");
vector_item.emplace_back ("to");
vector_item.emplace_back ("emplace_back Method");
per (auto it = vector_item.inizio(); Esso != vector_item.FINE(); ++ esso)
cout<< " << *it;
restituzione 0;

Dopo aver impostato lo spazio dei nomi, abbiamo creato il metodo principale di questo particolare programma. Al suo interno, abbiamo stabilito l'oggetto della classe vettoriale come "vector_item". Quindi, abbiamo chiamato questo oggetto "vector_item" con il metodo emplace_back () e inserito gli elementi vettoriali come argomento. Abbiamo inserito i vettori di stringa nel metodo EMPlace_back (). Per visualizzare questi vettori di stringa nella schermata della console, abbiamo distribuito il metodo Loop "per". Puoi vedere che tutte le stringhe vettoriali sono generate in forma orizzontale.

Esempio 3:

L'esempio per dimostrare il vettore dei caratteri usando la funzione EMPlace_back ().

#includere
#includere
Utilizzo dello spazio dei nomi std;
int main ()

vectormyvec;
Myvec.emplace_back ('l');
Myvec.emplace_back ('i');
Myvec.emplace_back ('n');
Myvec.emplace_back ('u');
Myvec.emplace_back ('x');
per (auto it = myvec.inizio(); Esso != Myvec.FINE(); ++ esso)
cout<< " << *it;
restituzione 0;

Abbiamo creato l'oggetto vettoriale come "myvec". Quindi, con l'oggetto vettoriale "MyVec", abbiamo chiamato il metodo EMPlace_back (). Inseriamo i diversi caratteri ogni volta sul metodo EMPlace_back (). Il ciclo "per" viene utilizzato per stampare i valori dei caratteri dal metodo EMPlace_back (). La schermata seguente mostra il valore del carattere restituito dal metodo EMPlace_back ().

Esempio 4:

Utilizzare la funzione emplace_back () per aggiungere i numeri interi a un vettore vuoto e quindi determinare la dimensione del vettore risultante. Per questo, abbiamo un algoritmo. L'algoritmo è che dobbiamo utilizzare la funzione EMPlace_back () per aggiungere gli elementi al vettore. Quindi, controlla se la dimensione del vettore è 0. In caso contrario, fai scoppiare l'elemento posteriore e aumenta la variabile contatore inizialmente inizializzata su 0. Una volta che la dimensione del vettore è ridotta a 0, ripeti questa procedura. Visualizza il valore finale della variabile.

#includere
#includere
Utilizzo dello spazio dei nomi std;
int main ()

int count = 0;
vectorv;
v.emplace_back (1);
v.emplace_back (2);
v.emplace_back (3);
v.emplace_back (4);
Mentre (!v.vuoto())
conta ++;
v.pop_back ();

cout<< "count value:" ;
cout<restituire 0;

Lì, abbiamo il metodo principale di questo programma. Abbiamo il "conteggio" variabile che viene inizializzato con il valore zero. Quindi, abbiamo un oggetto "V" dal vettore di classe. Abbiamo il metodo EMPlace_back () attraverso il quale abbiamo inserito gli elementi interi. Successivamente, abbiamo un ciclo di tempo che stampa il valore del conteggio. L'elemento vettoriale non deve essere zero affinché il ciclo while sia in vigore. Quindi, il conteggio viene incrementato dal metodo pop_back (). Di seguito è riportato una schermata che mostra il valore del conteggio:

Esempio 5:

Il push_back () converte una stringa in un vettore. Un nuovo oggetto stringa viene prima generato e inizializzato implicitamente con il carbone fornito*. La stringa originale è un oggetto temporaneo, viene quindi invocato. Copia questa stringa nel vettore con il costruttore della funzione. Quindi, l'oggetto transitorio viene distrutto. D'altra parte, EMPlace_back () costruisce le corde in posizione, non vengono create stringhe temporanee; Invece, emplace_back () viene chiamato direttamente con un parametro char*. Quindi, genera una stringa che viene salvata nel vettore inizializzato con questo carattere*. In questo modo, evitiamo di creare e smaltire un oggetto di stringa temporanea inutile.

#includere
Utilizzo dello spazio dei nomi std;
int main ()

vettoremy_vect;
my_vect.emplace_back ('x', 12);
my_vect.push_back (make_pair ('y', 15));
per (int i = 0; icout<<restituzione 0;

All'interno del principale INT, abbiamo dichiarato che la coda vettoriale prioritaria è dichiarata come oggetto "my_vect". Quindi, abbiamo il metodo EMPlace_back () che ha in atto l'input di coppia. Successivamente, abbiamo inserito i valori della coppia con il metodo push_back (). Sia i valori della coppia da EMPlace_back () che per Push_back () sono stampati con l'aiuto di un loop. I valori di coppia inseriti vengono eseguiti nel seguente prompt:

Conclusione

Ora, è molto chiaro per te la funzionalità del metodo EMPlace_back () in C++. Il vantaggio di sbirciarsi è che esegue un inserimento sul posto e impedisce la necessità di duplicare un oggetto. Quale che utilizziamo non importa per i tipi di dati primitivi. Tuttavia, l'utilizzo di EMPlace () è raccomandato per gli oggetti a causa delle sue prestazioni. Abbiamo coperto tutti i possibili programmi di esempio per spiegare la funzione EMPlace_back (). Inoltre, abbiamo differenziato tra il metodo EMPlace_back () e il metodo push_back () con il programma di esempio.