¿Cómo encuentras algo en un vector en c?++?
Para usar las bibliotecas de vector y algoritmo, el programa C ++ debe comenzar con:
#incluir#incluir
#incluir
usando el espacio de nombres STD;
Este tutorial da los conceptos básicos de encontrar un valor en un vector C ++. Todo el código en este tutorial está en la función Main (), a menos que se indique lo contrario. Si el vector consiste en cadenas, use la clase de cadena; y no use "const char*". En este caso, la clase de cadena también debe incluirse, como así:
#incluirContenido del artículo
- encontrar()
- Encontrar entero
- Predicado
- Conclusión
Encontrar
InputIterator Find (InputIterator First, Inputiterator Last, Const T & Value);
El siguiente código utiliza esta función para saber si la flor, "Cornflower" se encuentra entre una lista vectorial de flores:
#incluir#incluir
#incluir
#incluir
usando el espacio de nombres STD;
int main ()
vectorvtr = "Dog Rose", "HoneySuckle", "Enchanter's Nightshade", "Columbine", "Kingcup", "Cornflower", "Water Avens", "Forget-yo-no-no";
vector :: iterator it = find (vtr.begin (), VTR.end (), "Cornflower");
if (it == vtr.fin())
cout<< "Flower was not found!" <
cout<< "Flower found at index: " << it - vtr.begin() <
La salida es:
Flor encontrada en el índice: 5Toda la lista del vector ha sido el objetivo del hallazgo. De la sintaxis de la función find (), "primero" es VTR.begin () en el código, y "último" es VTR.end () en el código. El valor a buscar desde la función de la función find () denotada por const-t & -alvalue, es "maíz" en el código.
La función find () escanea la lista de vectores desde el principio. Si no ve el valor que está buscando, llegará al final del vector. El final del vector es oficialmente VTR.end (), que está más allá del último elemento. Si no ve el valor que está buscando, devolverá el iterador apuntando a VTR.fin().
El valor que está buscando puede estar en diferentes lugares del mismo vector. Cuando ve el primero de los valores que está buscando, se detiene allí y devuelve el iterador que apunta a ese valor.
Cada valor en un vector tiene un índice. El primer valor tiene índice 0, correspondiente a VTR.comenzar(). El segundo valor tiene índice 1, correspondiente a VTR.begin () + 1. El tercer valor tiene el índice 2, correspondiente a VTR.begin () + 2. El cuarto valor tiene el índice 3, correspondiente a VTR.begin () + 3; etcétera. Entonces, el índice del primer valor encontrado está dado por:
It - VTR.comenzar()Sensibilidad de casos
Encontrar en un vector es sensible a los casos. Si el valor que se encuentra fue "Cornflower" para el programa anterior, no se habría encontrado y VTR.end () habría sido devuelto.
Rango dentro de los límites
El rango no debe ser necesariamente todo el vector. Para el programa anterior, el rango podría haber sido del índice 1 al índice 4. Es decir, de "VTR.begin () + 1 "a" VTR.end () - 4 ". "VTR.End () - 4 ”se obtiene restando desde la parte posterior, teniendo en cuenta que VTR.end () está justo más allá del último elemento.
Cuando toda la lista de vectores es el rango, prueba si el iterador de retorno es VTR.end () indica si el valor se encontró o no. Si el iterador de retorno es VTR.end (), significa que el valor no se encontró. Ahora, cuando el rango es más pequeño, si el iterador de retorno es el último elemento del rango elegido, significa que el valor no se encontró o es el último valor del rango.
Nota: Buscar paradas en el último elemento del rango elegido (más pequeño), si el valor no se encontró en ese rango, o si el valor encontrado, es el último elemento del rango elegido. Si el valor encontrado fue ese último elemento, se devolvería un iterador que apunta a él. Si el valor se encontró antes, la búsqueda se detendría en ese elemento antes del último elemento del rango elegido. El iterador de ese elemento antes sería devuelto.
El siguiente código ilustra este esquema:
#incluir#incluir
#incluir
#incluir
usando el espacio de nombres STD;
int main ()
vectorvtr = "Dog Rose", "HoneySuckle", "Enchanter's Nightshade", "Columbine", "Kingcup", "Cornflower", "Water Avens", "Forget-yo-no-no";
vector :: iterator it = find (vtr.begin () + 1, VTR.end () - 4, "Cornflower");
if (it == vtr.fin())
cout<< "Flower was not found!" <
if (*it == String ("Cornflower"))
cout<< "Flower found at index: " << it - vtr.begin() <
cout<< "Flower was not found in range!" <
demás
cout<< "Flower found at index: " << it - vtr.begin() <
regresar 0;
La salida es:
La flor no se encontró en el rango!Ahora, "Cornflower" está en el índice 5, y "Kingcup" está en el índice 4. El último elemento en la pequeña gama elegida para la búsqueda es "Kingcup". Entonces, la condición de prueba correspondiente es "It - VTR.begin () == 4 ". Tenga en cuenta que las expresiones, "VTR.end () - 4 "y" It - VTR.begin () == 4 ”Cada uno tiene 4, es solo una coincidencia.
Para tener "cañón de maíz" en el rango pequeño de búsqueda, la condición de prueba correspondiente tendrá que ser "VTR - VTR.begin () == 5 ". El siguiente código ilustra esto:
#incluir#incluir
#incluir
#incluir
usando el espacio de nombres STD;
int main ()
vectorvtr = "Dog Rose", "HoneySuckle", "Enchanter's Nightshade", "Columbine", "Kingcup", "Cornflower", "Water Avens", "Forget-yo-no-no";
vector :: iterator it = find (vtr.begin () + 1, VTR.end () - 3, "Cornflower");
if (it == vtr.fin())
cout<< "Flower was not found!" <
if (*it == String ("Cornflower"))
cout<< "Flower found at index: " << it - vtr.begin() <
cout<< "Flower was not found in range!" <
demás
cout<< "Flower found at index: " << it - vtr.begin() <
regresar 0;
La salida es:
Flor encontrada en el índice: 5Más de un ocurrencia
En el siguiente programa, "Cornflower" ocurre en más de un lugar. Para encontrar todos los índices de los ocurrencias, use un bucle de tiempo para continuar la búsqueda, después de la ocurrencia anterior, hasta el final (VTR.end ()) del vector. El programa es:
#incluir#incluir
#incluir
#incluir
usando el espacio de nombres STD;
int main ()
vectorvtr = "Dog Rose", "Cornflower", "Enchanter's Nightshade", "Columbine", "Kingcup", "Cornflower", "Water Avens", "Cornflower";
vector :: iterator it = find (vtr.begin (), VTR.end (), "Cornflower");
mientras ( != VTR.fin())
if (*it == String ("Cornflower"))
cout<< "Flower found at index: " << it - vtr.begin() <
regresar 0;
La salida es:
Flor encontrada en el índice: 1Flor encontrada en el índice: 5
Flor encontrada en el índice: 7
Encontrar entero
Un vector puede consistir en enteros. Se puede encontrar un primer valor entero utilizando la función find () (desde la biblioteca de algoritmo). El siguiente programa ilustra esto:
#incluir#incluir
#incluir
usando el espacio de nombres STD;
int main ()
vectorvtr = 1, 2, 3, 1, 2, 3, 1, 2, 3;
vector :: iterator it = find (vtr.begin (), VTR.end (), 3);
if (it == vtr.fin())
cout<< "Number was not found!" <
cout<< "Number found at index: " << it - vtr.begin() <
La salida es:
Número encontrado en el índice: 2Para la primera ocurrencia del valor, 3.
Predicado
InputIterator find_if (Inputiterator First, Inputiterator Last, predicado Pred);
La función aquí es find_if () y no solo find (). Pred es el nombre de la función que da los criterios de búsqueda. Este tercer argumento toma solo el nombre de la función, sin argumentos y sin paréntesis. Si la función de predicado toma argumento, entonces en la definición de función, los parámetros para los argumentos se dan. El siguiente programa ilustra esto, buscando el primer número par en la lista de vectores:
#incluir#incluir
#incluir
usando el espacio de nombres STD;
bool fn (int n)
if ((n % 2) == 0)
devolver verdadero;
demás
falso retorno;
int main ()
vectorvtr = 1, 3, 5, 7, 8, 9, 10, 11, 12;
vector :: iterator it = find_if (VTR.begin (), VTR.end (), fn);
if (it == vtr.fin())
cout<< "Number was not found!" <
cout<< "Number found at index: " << it - vtr.begin() <
La salida es:
Número encontrado en el índice: 4Tenga en cuenta que todo el vector ha sido registrado, con el rango, "VTR.begin (), VTR.fin()".
El nombre de la función de predicado aquí es, FN. Se necesita un argumento, n un int. Como la función find_if () comienza a escanear el vector desde el primer elemento, llama a la función de predicado con cada número en el vector como argumento. El escaneo se detiene cuando alcanza el primer elemento en el vector donde el predicado regresa verdadero.
Conclusión
La función find () en la biblioteca de algoritmo existe en cuatro categorías, que son: encontrar, encontrar fin, encontrar primero y adyacente encontrar. Solo la categoría, Find se ha explicado anteriormente, y en gran medida. La explicación dada anteriormente son las bases para todas las funciones find () en la biblioteca de algoritmo. Find () Las funciones tratan directamente con los iteradores y tratan con índices indirectamente. El programador tiene que saber cómo convertir el iterador en índice y aritmética iteradora general como se ilustra arriba.