Funciones de miembros vectoriales más útiles de C ++

Las funciones de miembros del vector C ++ se pueden colocar en las siguientes categorías: construcción, capacidad, iteradores, acceso de elementos y modificadores. Cada una de estas categorías tiene muchas funciones. Todas estas funciones no se utilizan en muchas aplicaciones. Este artículo explica la más útil de estas funciones. Con la excepción de la categoría de modificadores, no se explican más de tres funciones para cada categoría en este artículo. La categoría de modificadores se puede dividir en más subcategorías. En cada una de estas subcategorías, no se explicarán más de tres funciones. Si se explicarán más de tres funciones para una categoría determinada, entonces se les enseñará a modo de ilustración.

Un programa para usar C ++ Vector debe comenzar con,

#incluir
#incluir

Contenido del artículo

• Construcción/destrucción
• Capacidad
• Acceso iterador y vectorial
• Acceso al elemento
• Empuje hacia atrás y vuelva hacia atrás
• Inserción
• Asignación de elementos (reemplazos)
• Borrar
• Claro
• Intercambio
• Conclusión

Construcción/destrucción

Los siguientes segmentos de código muestran diferentes formas de crear el mismo vector:

vector 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);
vector VTR (3); // con número inicial de elementos
VTR [0] = 5.5;
VTR [1] = 6.6;
VTR [2] = 7.7;
vector VTR (5, 0.0); //No. Elementos: 5; Cada valor: 0.0
vector VTR 5.5, 6.6, 7.7, 8.8, 9.9; // Inicialización
vector vtr = 5.5, 6.6, 7.7, 8.8, 9.9; // Construyendo y copiando
vector VTR;
vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vector VTR1 5.5, 6.6, 7.7, 8.8, 9.9;
vector VTR2 (VTR1);
vector constante vtr = 5.5, 6.6, 7.7, 8.8, 9.9;

A vector constante es un vector cuyos elementos no se pueden cambiar. Los valores son de solo lectura.

Destrucción

Para destruir un vector, solo déjelo salir del alcance.

Capacidad

size () const noexcept

El número de elementos en un vector es devuelto por esta función de miembro. Con el siguiente segmento de código, la salida es 5:

vector vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
flotante sz = vtr.tamaño();
cout << sz << '\n';
vacía () const noexcept

Este método devuelve verdadero (1) si el vector no tiene elemento y falso (0) si el vector tiene al menos un elemento. Con el siguiente código, la salida es 1 (para verdadero):

vector vtr = ;
bool bl = vtr.vacío();
cout << bl << '\n';

Acceso iterador y vectorial

Un iterador es un puntero elaborado. Cuando el vector, VTR Ha sido creado, VTR.comenzar() devolvería un iterador, señalando el primer elemento de la lista. Luego se puede incrementarse para acceder a los elementos después de los primeros, en consecuencia.

Cuando el vector, VTR Ha sido creado, VTR.fin() devolvería un iterador, señalando justo después del último elemento de la lista. Luego se puede disminuir para acceder al último elemento y elementos antes del último, en consecuencia. El siguiente programa ilustra esto:

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

vector vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vector:: iterator iterb = vtr.comenzar();
iterb ++;
vector:: iterator ITere = VTR.fin();
Itere--;
cout << *iterB << ", " << *iterE << " << endl;
*iterb = 66.66; *ITERE = 99.99;
cout << *iterB << ", " << *iterE << " << endl;
regresar 0;

La salida es:

6.6, 9.9
66.66, 99.99

Los valores de dos elementos fueron accedidos, leídos y cambiados por dos iteradores.

Acceso al elemento

en (i)

Esto es similar a VTR [i], y es mejor. Se puede usar para leer o cambiar el valor de un elemento. El conteo de índice comienza desde cero. El lector puede probar el siguiente programa:

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

vector 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;
regresar 0;

La salida es:

6.6, 9.9
66.66, 99.99

Se accedió, leí y cambió los valores de dos elementos mediante la referencia.

Devolviendo el primer valor

El siguiente código devuelve (copia) el primer elemento:

vector vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
flotante val = VTR.frente();
cout << val << endl;

La salida es, 5.5. La función miembro utilizada aquí es: front ().

Devolviendo el último valor

El siguiente código devuelve (copia) el último elemento:

vector vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
flotante val = VTR.atrás();
cout << val << endl;

La salida es, 9.9. La función miembro utilizada aquí es: back ().

Empuje hacia atrás y vuelva hacia atrás

hacer retroceder()

Se puede agregar un elemento en la parte posterior del vector. El valor puede ser literal o ser representado por el identificador. El siguiente código ilustra esto:

flotante flt = 10.10;
vector vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
VTR.push_back (flt);
para (int i = 0; icout << vtr[i] << ", ";
cout << endl;

La lista original es:

5.5, 6.6, 7.7, 8.8, 9.9

La nueva lista es:

5.5, 6.6, 7.7, 8.8, 9.9, 10.1

pop_back ()

El último elemento se puede eliminar del vector. El siguiente código ilustra esto:

vector vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
VTR.pop_back ();
para (int i = 0; icout << vtr[i] << ", ";
cout << endl;

La lista original es:

5.5, 6.6, 7.7, 8.8, 9.9

La nueva lista es:

5.5, 6.6, 7.7, 8.8

Nota: El vector no tiene funciones de miembro push_front () y pop_front ().

Inserción

Insertos frente al elemento apuntado a, por el iterador.

insertar (p, e)

Esto inserta un elemento antes de que el elemento apunte por el iterador, p. E puede ser un literal o identificador. Ilustración:

flotante flt = 7.0;
vector vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vector:: iterator iterb = vtr.comenzar();
iterb ++; iterb ++;
VTR.insertar (iterb, flt);
para (int i = 0; icout << vtr[i] << ", ";
cout << endl;

La lista original es:

5.5, 6.6, 7.7, 8.8, 9.9

La nueva lista es:

5.5, 6.6, 7, 7.7, 8.8, 9.9

Esta función de inserción devuelve un iterador (no codificado) que apunta al elemento insertado.

Insertar (P, IL)

Se puede insertar una lista frente al elemento señalado por el iterador. Ilustración:

vector vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vector:: iterator iterb = vtr.comenzar();
iterb = iterb + 2;
VTR.insertar (iterb, 7.1, 7.2, 7.3);
para (int i = 0; icout << vtr[i] << ", ";
cout << endl;

La lista original es:

5.5, 6.6, 7.7, 8.8, 9.9

La nueva lista es:

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

Esta función de inserción devuelve un iterador (no codificado) que apunta al primer elemento insertado.

Insertar (P, N, T)

Inserta el mismo valor t, n veces, frente al elemento apuntado por P. Ilustración:

vector vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vector:: iterator iterb = vtr.comenzar();
iterb = iterb + 2;
VTR.insertar (iterb, 3, 7.1);
para (int i = 0; icout << vtr[i] << ", ";
cout << endl;

La lista original es:

5.5, 6.6, 7.7, 8.8, 9.9

La nueva lista es:

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

Esta función de inserción devuelve un iterador (no codificado) que apunta al primer elemento insertado.

insertar (p, i, j)

Se puede copiar un rango de otro vector e insertarse en el vector de interés. El siguiente código ilustra esto:

vector vtr1 = 7.1, 7.2, 7.3, 7.4, 7.5;
vector:: iterator iterb1 = vtr1.comenzar();
iterb1 = iterb1 + 1;
vector:: iterator ITERE1 = VTR1.fin();
ITERE1 = ITERE1 - 2;
vector vtr2 = 5.5, 6.6, 7.7, 8.8, 9.9;
vector:: iterator iterb2 = vtr2.comenzar();
iterb2 = iterb2 + 2;
VTR2.insertar (Iterb2, Iterb1, Itere1);
para (int i = 0; icout << vtr2[i] << ", ";
cout << endl;

La lista original para VTR2 es:

5.5, 6.6, 7.7, 8.8, 9.9

La nueva lista para VTR2 es:

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

El rango identificado para ser copiado es [7.2, 7.3, 7.4), indicado como [i, j), que significa el último valor, 7.4 no está incluido.

Esta función de inserción devuelve un iterador (no codificado) que apunta al primer elemento insertado.

Asignación de elementos (reemplazos)

Asignar a elementos significa reemplazar los elementos con copias. Todas las funciones de los miembros de la asignación, retorno nula.

Asignar (IL)

Una lista puede reemplazar todos los elementos en el vector en cuestión. La lista puede ser más larga o más corta. Ilustración para la lista corta:

vector vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vector:: iterator iterb = vtr.comenzar();
iterb = iterb + 2;
VTR.asignar (55.55, 66.66, 77.77);
para (int i = 0; icout << vtr[i] << ", ";
cout << endl;

La lista original es:

5.5, 6.6, 7.7, 8.8, 9.9

La nueva lista es:

55.55, 66.66, 77.77

Ilustración para una lista más larga:

vector vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vector:: iterator iterb = vtr.comenzar();
iterb = iterb + 2;
VTR.asignar (55.55, 66.66, 77.77, 88.88, 99.99, 1010.1111);
para (int i = 0; icout << vtr[i] << ", ";
cout << endl;

La lista original es:

5.5, 6.6, 7.7, 8.8, 9.9

La nueva lista es:

55.55, 66.66, 77.77, 88.88, 99.99, 1010.11

Asignar (n, t)

El mismo valor, repetido varias veces, puede reemplazar todos los elementos en el vector en cuestión. La nueva lista puede ser más larga o más corta. Ilustración para la lista corta:

vector vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vector:: iterator iterb = vtr.comenzar();
iterb = iterb + 2;
VTR.Asignar (2, 77.77);
para (int i = 0; icout << vtr[i] << ", ";
cout << endl;

La lista original es:

5.5, 6.6, 7.7, 8.8, 9.9

La nueva lista es:

77.77, 77.77

Asignar (i, j)

Se puede copiar un rango de otro vector y usarse para reemplazar todo el contenido del vector de interés. El siguiente código ilustra esto:

vector vtr1 = 7.1, 7.2, 7.3, 7.4, 7.5;
vector:: iterator iterb1 = vtr1.comenzar();
iterb1 = iterb1 + 1;
vector:: iterator ITERE1 = VTR1.fin();
ITERE1 = ITERE1 - 2;
vector vtr2 = 5.5, 6.6, 7.7, 8.8, 9.9;
vector:: iterator iterb2 = vtr2.comenzar();
iterb2 = iterb2 + 2;
VTR2.asignar (iterb1, itere1);
para (int i = 0; icout << vtr2[i] << ", ";
cout << endl;

La lista original para VTR2 es:

5.5, 6.6, 7.7, 8.8, 9.9

La nueva lista para VTR2 es:

7.2, 7.3

El rango identificado para ser copiado es [7.2, 7.3, 7.4), indicado como [i, j), que significa el último valor, 7.4 no está incluido.

Borrar

Usa iterador.

borrar (Q)

Elimina el elemento apuntado por Q, acortando la longitud del vector. Devuelve el iterador apuntando al siguiente elemento, después de la extracción. Ejemplo:

vector vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vector:: iterator iterb = vtr.comenzar();
iterb = iterb + 2;
vector:: iterator ITR = VTR.borrar (iterb);
para (int i = 0; icout << vtr[i] << ", ";
cout << endl;
cout << *itR << endl;

La lista original es:

5.5, 6.6, 7.7, 8.8, 9.9

La salida es:

5.5, 6.6, 8.8, 9.9,
8.8

borrar (Q1, Q2)

Elimina un rango de elementos que comienzan desde el señalado por el iterador Q1, a la señal de Q2, pero excluyendo el de Q2, es decir, elimina [Q1, Q2). Devuelve el iterador apuntando al siguiente elemento, después de la eliminación del rango. Ilustración:

vector vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vector:: iterator iterb = vtr.comenzar();
iterb = iterb + 2;
vector:: iterator ITere = VTR.fin();
ITERE = ITERE - 1;
vector:: iterator ITR = VTR.borrar (iterb, Itere);
para (int i = 0; icout << vtr[i] << ", ";
cout << endl;
cout << *itR << endl;

La lista original es:

5.5, 6.6, 7.7, 8.8, 9.9

La salida es:

5.5, 6.6, 9.9,
9.9

Claro

claro()

Devuelve nulo. Se pueden eliminar todos los elementos en un vector, reduciendo la longitud del vector a cero. Así es como:

vector vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
VTR.claro();
cout << vtr.size() << endl;

La lista original es:

5.5, 6.6, 7.7, 8.8, 9.9

La salida es:

0

Intercambio

X.intercambio (y)

Los elementos de dos vectores diferentes se pueden cambiar, independientemente de sus diferentes longitudes. Ilustración:

vector vtr1 = 1.1, 2.2, 3.3, 4.4;
vector vtr2 = 5.5, 6.6, 7.7, 8.8, 9.9;
VTR2.intercambio (VTR1);
cout << "New vtr1: ";
para (int i = 0; icout << vtr1[i] << ", ";
cout << endl;
cout << "New vtr2: ";
para (int i = 0; icout << vtr2[i] << ", ";
cout << endl;

La salida es:

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

Conclusión

C ++ Vector tiene muchas funciones de miembros. Estas funciones se pueden clasificar en las siguientes subcategorías: construcción/destrucción, capacidad, acceso iterador y vectorial, acceso de elementos, retroceder y hacer retroceder, insertar, asignar elementos (reemplazos), borrar, despejar y intercambiar. Las funciones más útiles en cada una de estas subcategorías se han explicado anteriormente.