C ++ emplace_back

El método C ++ std :: vector :: emplace_back () extiende el vector agregando un nuevo elemento. Si se requiere espacio adicional, se realiza la reasignación. Cuando se agrega o retira un elemento, los vectores tienen una capacidad similar a las matrices dinámicas para cambiar el tamaño automáticamente. El contenedor maneja automáticamente el almacenamiento vectorial. Además de eso, usando la función emPlace_back (), se puede agregar un elemento al final de un vector, siguiendo el que ya está allí. Esta estructura ya existe. Continuemos con algunos ejemplos para comprender más sobre el método emplace_back ().

Sintaxis del emplace_back () en c++

La declaración para la función std :: vector :: emplace_back () desde el encabezado std :: vector se proporciona en lo siguiente:

# vector.emplace_back (elemento);

El parámetro es el elemento que se agrega al vector. Los resultados son el parámetro que se inserta en el vector en el último punto. Se emite una excepción llamada bad_alloc si la reasignación falla. Si se lanza una excepción, no se cambia nada debido a la fuerte garantía de excepción. Para evitar que se arroje un error, el parámetro debe ser del mismo tipo que el contenedor.

Ejemplo 1:

El uso de la función emplace_back () se demuestra en el siguiente ejemplo:

#incluir
#incluir
usando el espacio de nombres STD;
int main ()

vectorvec;
VEC.emplace_back (1);
VEC.emplace_back (2);
VEC.emplace_back (3);
VEC.emplace_back (4);
VEC.emplace_back (5);
para (auto it = vec.comenzar(); él != VEC.fin(); ++ it)
cout<< " << *it;
regresar 0;

Importamos los módulos para el uso de métodos y clases en el programa. Comience con la función principal de ejemplo. Creamos un objeto como "vec" de vectores de clase con el tipo de datos int int. Luego, invocamos el método emPlace_back () con cada objeto vectorial e insertamos un elemento vectorial como argumento en el método emplace_back (). El bucle "para" se usa para mostrar los componentes de los vectores. En el bucle for, tenemos una palabra clave automática con la variable "it" que se establece con el método BEGIN. También establecemos su variable con el método final. Esto itera el elemento vectorial con el operador de incremento y devuelve los elementos en los vectores como se muestra en la siguiente pantalla de salida:

Ejemplo 2:

Como en el ejemplo anterior, tenemos un ejemplo de vector entero que usa la función emplace_back (). Ahora, tenemos un ejemplo de un programa de vector de cadena para demostrar el uso de la función emplace ().

#incluir
#incluir
#incluir
usando el espacio de nombres STD;
int main ()

vectorVector_item;
vector_item.emplace_back ("hola");
vector_item.emplace_back ("my");
vector_item.emplace_back ("geeks");
vector_item.emplace_back ("a");
vector_item.emplace_back ("Método emplace_back");
para (auto it = vector_item.comenzar(); él != vector_item.fin(); ++ it)
cout<< " << *it;
regresar 0;

Después de establecer el espacio de nombres STD, creamos el método principal de este programa en particular. Dentro de él, establecimos el objeto de clase Vector como "vector_item". Luego, llamamos a este objeto "vector_item" con el método emplace_back () e insertamos los elementos de vector como argumento. Insertamos los vectores de cadena en el método emplace_back (). Para mostrar estos vectores de cadena en la pantalla de la consola, implementamos el método de bucle "para". Puede ver que todas las cadenas vectoriales se generan en forma horizontal.

Ejemplo 3:

El ejemplo para demostrar el vector de caracteres usando la función emPlace_back ().

#incluir
#incluir
usando el espacio de nombres STD;
int main ()

vectormyvec;
Myvec.emplace_back ('l');
Myvec.emplace_back ('i');
Myvec.emplace_back ('n');
Myvec.emplace_back ('u');
Myvec.emplace_back ('x');
para (auto it = myVec.comenzar(); él != MyVec.fin(); ++ it)
cout<< " << *it;
regresar 0;

Creamos el objeto Vector como "myvec". Luego, con el objeto vectorial "myVec", llamamos al método emPlace_back (). Ingresamos los diferentes caracteres cada vez al método emplace_back (). El bucle "para" se usa para imprimir los valores del personaje desde el método emPlace_back (). La siguiente pantalla muestra el valor del personaje devuelto del método emPlace_back ().

Ejemplo 4:

Use la función emplace_back () para agregar los enteros a un vector vacío y luego determinar el tamaño del vector resultante. Para esto, tenemos un algoritmo. El algoritmo es que tenemos que utilizar la función emplace_back () para agregar los elementos al vector. Luego, verifique si el tamaño del vector es 0. De lo contrario, establezca el elemento posterior y aumente la variable de contador que inicialmente se inicializó a 0. Una vez que el tamaño del vector se reduzca a 0, repita este procedimiento. Muestra el valor final de la variable.

#incluir
#incluir
usando el espacio de nombres STD;
int main ()

int count = 0;
vectorv;
V.emplace_back (1);
V.emplace_back (2);
V.emplace_back (3);
V.emplace_back (4);
mientras (!V.vacío())
contar ++;
V.pop_back ();

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

Allí tenemos el método principal de este programa. Tenemos la variable "recuento" que se inicializa con el valor cero. Entonces, tenemos un objeto "V" del vector de clase. Tenemos el método emplace_back () a través del cual insertamos los elementos enteros. Después de eso, tenemos un bucle de tiempo que imprime el valor de conteo. El elemento vectorial no debe ser cero para el bucle while en efecto. Entonces, el recuento se incrementa mediante el método pop_back (). La siguiente es una pantalla que muestra el valor de conteo:

Ejemplo 5:

El push_back () convierte una cadena en un vector. Primero se genera e inicializa un nuevo objeto de cadena con el char* suministrado*. La cadena original es un objeto temporal, se invoca empuje hacia atrás. Copie esta cadena en el vector con el constructor de función de movimiento. Entonces, el elemento transitorio se destruye. Por otro lado, el emplace_back () construye las cuerdas en su lugar, no se crean cadenas temporales; en su lugar, emplace_back () se llama directamente con un parámetro char*. Luego, genera una cadena que se guarda en el vector que se inicializó con este char*. De esta manera, evitamos crear y eliminar un objeto de cadena temporal sin sentido.

#incluir
usando el espacio de nombres STD;
int main ()

vectormy_vect;
my_vect.emplace_back ('x', 12);
my_vect.push_back (make_pair ('y', 15));
para (int i = 0; icout<<regresar 0;

Dentro del int Main, declaramos que la cola de vectores de prioridad se declara como el objeto "my_vect". Luego, tenemos el método emplace_back () que tiene la entrada del par en su lugar. Después de eso, insertamos los valores del par con el método push_back (). Ambos valores del par desde el emplace_back () y el push_back () se imprimen con la ayuda de un bucle for bucle. Los valores del par insertados se ejecutan en el siguiente mensaje:

Conclusión

Ahora, es muy claro para usted la funcionalidad del método emplace_back () en c++. El beneficio del emplace es que realiza una inserción en el lugar y evita la necesidad de duplicar un objeto. Cuál que usamos no importa para los tipos de datos primitivos. Sin embargo, el uso del emplace () se recomienda para los objetos debido a su rendimiento. Cubrimos todos los programas de ejemplo posibles para explicar la función emplace_back (). Además, diferenciamos entre el método emplace_back () y el método push_back () con el programa de ejemplo.