Como você encontra algo em um vetor em c++?

Shaun Bogan

O vetor C ++ não possui uma função de membro. No entanto, a biblioteca de algoritmo possui uma função encontrada () de diferentes tipos que podem ser usados para encontrar algo em um vetor C ++. A biblioteca de algoritmo possui quatro grupos de funções de find () que podem ser classificadas como encontre, encontre final, encontre primeiro e achado adjacente.

Para usar as bibliotecas de vetor e algoritmo, o programa C ++ deve começar com:

#incluir
#incluir
#incluir
usando namespace std;

Este tutorial fornece o básico de encontrar um valor em um vetor C ++. Todo o código deste tutorial está na função principal (), a menos que indicado de outra forma. Se o vetor consistir em strings, use a classe String; e não use “const char*”. Nesse caso, a classe String também deve ser incluída, assim:

#incluir

Conteúdo do artigo

encontrar()
Encontrando o número inteiro
Predicado
Conclusão

Encontrar

InputIterator encontrado (InputIterator First, inputIterator Último, const t & value);

O código a seguir usa esta função para saber se a flor, "milhoflower" está entre uma lista vetorial de flores:

A saída é:

Flor Encontrada no Índice: 5

Toda a lista do vetor tem sido o alvo para a descoberta. Da sintaxe da função find (), "primeiro" é VTR.BEGIN () no código, e "último" é VTR.end () no código. O valor a ser procurado na sintaxe da função find () indicada por const-t & -value, é "milhoflower" no código.

A função find () verifica a lista de vetores desde o início. Se não vê o valor que está procurando, chegará ao fim do vetor. O fim do vetor é oficialmente VTR.end (), que está logo além do último elemento. Se não vê o valor que está procurando, retornará o iterador apontando para VTR.fim().

O valor que está procurando pode estar em lugares diferentes no mesmo vetor. Quando vê o primeiro dos valores que está procurando, para por aí e retorna o iterador que está apontando para esse valor.

Cada valor em um vetor tem um índice. O primeiro valor tem índice 0, correspondente a VTR.começar(). O segundo valor tem índice 1, correspondente a VTR.BEGIN () + 1. O terceiro valor tem índice 2, correspondente a VTR.BEGIN () + 2. O quarto valor tem índice 3, correspondente a VTR.begin () + 3; e assim por diante. Portanto, o índice do primeiro valor encontrado é dado por:

It - vtr.começar()

Sensibilidade ao caso

Encontrar em um vetor é sensível ao minúsculo. Se o valor a ser encontrado fosse "Cornlower" para o programa acima, ele não teria sido encontrado e VTR.end () teria sido devolvido.

Variação dentro dos limites

O alcance não deve necessariamente ser o vetor inteiro. Para o programa acima, o intervalo poderia ter sido do índice 1 ao índice 4. Isto é, de “vtr.BEGIN () + 1 "para" VTR.end () - 4 ". “Vtr.end () - 4 ”é obtido subtraindo por trás, tendo em mente que o VTR.end () está logo além do último elemento.

Quando toda a lista de vetores é o intervalo, testando se o retorno é VTR.end () indica se o valor foi encontrado ou não. Se o iteador de retorno for VTR.end (), significa que o valor não foi encontrado. Agora, quando o intervalo é menor, se o iteador de retorno for o último elemento do intervalo escolhido, significa que o valor não foi encontrado ou é o último valor do intervalo.

Observação: Pesquisar paradas no último elemento do intervalo escolhido (menor), se o valor não foi encontrado nesse intervalo, ou se o valor encontrado, é o último elemento do intervalo escolhido. Se o valor encontrado fosse esse último elemento, um iterador apontando para ele seria devolvido. Se o valor fosse encontrado antes, a pesquisa iria parar nesse elemento antes do último elemento da faixa escolhida. O iterador desse elemento antes seria devolvido.

O código a seguir ilustra este esquema:

#incluir
#incluir
#incluir
#incluir
usando namespace std;
int main ()

Vectorvtr = "Dog Rose", "Honeysuckle", "Nightshade de Enchanter", "Columbine", "Kingcup", "Cornualha", "Avens de água", "esquecer-me-não";
vetor :: iterator it = find (vtr.BEGIN () + 1, VTR.end () - 4, "milhoflower");
if (it == vtr.fim())
cout<< "Flower was not found!" <senão se (it - vtr.begin () == 4) // Último elemento na faixa escolhida
if (*it == String ("Cornlower")))
cout<< "Flower found at index: " << it - vtr.begin() <outro
cout<< "Flower was not found in range!" <
outro
cout<< "Flower found at index: " << it - vtr.begin() <
retornar 0;

A saída é:

Flor não foi encontrado no alcance!

Agora, "Cornflower" está no índice 5 e "Kingcup" está no índice 4. O último elemento da pequena faixa escolhida para a busca é "Kingcup". Então, a condição de teste correspondente é “It - VTR.BEGIN () == 4 ". Observe que as expressões, “VTR.end () - 4 "e" it - vtr.BEGIN () == 4 ”cada um com 4, é apenas coincidência.

Para ter "milhoflower" na pequena faixa de pesquisa, a condição de teste correspondente terá que ser "It - VTR.BEGIN () == 5 ". O código a seguir ilustra o seguinte:

#incluir
#incluir
#incluir
#incluir
usando namespace std;
int main ()

Vectorvtr = "Dog Rose", "Honeysuckle", "Nightshade de Enchanter", "Columbine", "Kingcup", "Cornualha", "Avens de água", "esquecer-me-não";
vetor :: iterator it = find (vtr.BEGIN () + 1, VTR.end () - 3, "milhoflower");
if (it == vtr.fim())
cout<< "Flower was not found!" <senão se (it - vtr.begin () == 5)
if (*it == String ("Cornlower")))
cout<< "Flower found at index: " << it - vtr.begin() <outro
cout<< "Flower was not found in range!" <
outro
cout<< "Flower found at index: " << it - vtr.begin() <
retornar 0;

A saída é:

Flor Encontrada no Índice: 5

Mais de uma ocorrência

No programa seguinte, “milhoflower” ocorre em mais de um lugar. Para encontrar todos os índices das ocorrências, use um loop de tempo para continuar a pesquisa, após a ocorrência anterior, até o final (VTR.end ()) do vetor. O programa é:

#incluir
#incluir
#incluir
#incluir
usando namespace std;
int main ()

Vectorvtr = "Dog Rose", "Cornflower", "Enchanter's NightShade", "Columbine", "Kingcup", "Cornnclower", "Water Avens", "Cornflower";
vetor :: iterator it = find (vtr.BEGIN (), VTR.end (), "milhoflower");
Enquanto ele != vtr.fim())
if (*it == String ("Cornlower")))
cout<< "Flower found at index: " << it - vtr.begin() <It ++;

retornar 0;

A saída é:

Flor encontrada no índice: 1
Flor Encontrada no Índice: 5
Flor Encontrada no Índice: 7

Encontrando o número inteiro

Um vetor pode consistir em números inteiros. Um primeiro valor inteiro pode ser encontrado usando a função find () (da biblioteca de algoritmo). O programa a seguir ilustra o seguinte:

#incluir
#incluir
#incluir
usando namespace std;
int main ()

Vectorvtr = 1, 2, 3, 1, 2, 3, 1, 2, 3;
vetor :: iterator it = find (vtr.BEGIN (), VTR.end (), 3);
if (it == vtr.fim())
cout<< "Number was not found!" <outro
cout<< "Number found at index: " << it - vtr.begin() <retornar 0;

A saída é:

Número encontrado no índice: 2
para a primeira ocorrência do valor, 3.

Predicado

InputIterator find_if (inputIterator primeiro, inputIterator Último, predicado pred);

A função aqui é find_if () e não apenas encontre (). Pred é o nome da função que fornece os critérios de pesquisa. Este terceiro argumento leva apenas o nome da função, sem argumentos e sem parênteses. Se a função predicada assumir o argumento, então na definição da função, os parâmetros para os argumentos são dados. O programa a seguir ilustra isso, procurando o primeiro número par na lista de vetores:

#incluir
#incluir
#incluir
usando namespace std;
bool fn (int n)
if ((n % 2) == 0)
retornar true;
outro
retorna falso;

int main ()

vetorvtr = 1, 3, 5, 7, 8, 9, 10, 11, 12;
vetor :: iterator it = find_if (vtr.BEGIN (), VTR.end (), fn);
if (it == vtr.fim())
cout<< "Number was not found!" <outro
cout<< "Number found at index: " << it - vtr.begin() <retornar 0;

A saída é:

Número encontrado no índice: 4

Observe que todo o vetor foi pesquisado, com o intervalo, “VTR.BEGIN (), VTR.fim()".

O nome da função predicado aqui é, fn. É preciso um argumento, n a int. À medida que a função find_if () começa a digitalizar o vetor a partir do primeiro elemento, ela chama a função de predicado com cada número no vetor como argumento. A digitalização para quando atinge o primeiro elemento no vetor, onde o predicado retorna verdadeiro.

Conclusão

A função find () na biblioteca de algoritmo existe em quatro categorias, que são: encontre, encontre final, encontre primeiro e achado adjacente. Somente a categoria, descobriu foi explicada acima e, em grande parte. A explicação dada acima são as bases para todas as funções de find () na biblioteca de algoritmo. LINDO () Funções lidam com os iteradores diretamente e lidam com índices indiretamente. O programador precisa saber como converter o iterador para indexar e iterador geral aritmético, como ilustrado acima.

Powershell

Como instalar o Windows PowerShell

Para instalar o PowerShell primeiro, navegue até a Microsoft Store e pesquise PowerShell. Depois que...

Benny Hilll DDS

Programação Bash

Como verificar a existência do argumento de entrada em um script de shell bash

Podemos usar técnicas diferentes para verificar a existência de argumentos de entrada, como o uso do...

Joey Bartoletti

C ++

Programa C ++ para converter decimal para binário

Para converter um número decimal em binário em C ++, divida o número decimal por 2 até que o número ...

Marlon Bernhard