¿Cómo encuentro una posición de elemento en std :: vector?

Question

Tengo que encontrar una posición de elemento en un std :: vector para utilizarlo para hacer referencia a un elemento en otro vectorial:

int find(const vector<type>& where, int searchParameter) 
{ 
    for(int i = 0; i < where.size(); i++) { 
     if(conditionMet(where[i], searchParameter)) { 
      return i; 
     } 
    } 
    return -1; 
} 
// caller: 
const int position = find(firstVector, parameter); 
if(position != -1) { 
    doAction(secondVector[position]); 
} 

embargo vector::size() vuelve size_t lo que corresponde a un tipo entero unsigned que no pueden directamente tienda -1. ¿Cómo señalo que el elemento no se encuentra en un vector cuando se utiliza size_t en lugar de int como índice?

Answer 1

Puede usar std::numeric_limits<size_t>::max() para los elementos que no se encontraron. Es un valor válido, pero es imposible crear un contenedor con dicho índice máximo. Si std::vector tiene tamaño igual a std::numeric_limits<size_t>::max(), a continuación, el índice máximo permitido será (std::numeric_limits<size_t>::max()-1), ya que los elementos contados a partir de 0.

Answer 2

Eche un vistazo a las respuestas a esta pregunta: Invalid value for size_t?. También puede usar std :: find_if con std :: distance para obtener el índice.

std::vector<type>::iterator iter = std::find_if(vec.begin(), vec.end(), comparisonFunc); 
size_t index = std::distance(vec.begin(), iter); 
if(index == vec.size()) 
{ 
    //invalid 
} 

Answer 3

Probablemente no deba usar su propia función aquí. Use find() de STL.

Ejemplo:

 
list L; 
L.push_back(3); 
L.push_back(1); 
L.push_back(7);
 

list::iterator result = find(L.begin(), L.end(), 7); assert(result == L.end() || *result == 7); 

Answer 4

En este caso, es seguro que desechar la porción sin firmar a menos que el vector puede ser realmente grande.

Quitaría el where.size() a una variable local ya que no cambiará durante la llamada. Algo como esto:

int find(const vector<type>& where, int searchParameter){ 
    int size = static_cast<int>(where.size()); 
    for(int i = 0; i < size; i++) { 
     if(conditionMet(where[i], searchParameter)) { 
      return i; 
     } 
    } 
    return -1; 
} 

Answer 5

Antes que nada, ¿realmente necesita almacenar índices como este? ¿Has buscado en std :: map, lo que te permite almacenar claves => pares de valores?

En segundo lugar, si utilizó iteradores en su lugar, podría devolver std :: vector.end() para indicar un resultado no válido. Para convertir un iterador en un índice, simplemente use

size_t i = it - myvector.begin(); 

Answer 6

Algo así, creo. find_if_counted.hpp:

#ifndef FIND_IF_COUNTED_HPP 
#define FIND_IF_COUNTED_HPP 

#include <algorithm> 

namespace find_if_counted_impl 
{ 
    template <typename Func> 
    struct func_counter 
    { 
     explicit func_counter(Func& func, unsigned &count) : 
     _func(func), 
     _count(count) 
     { 
     } 

     template <typename T> 
     bool operator()(const T& t) 
     { 
      ++_count; 

      return _func(t); 
     } 

    private: 
     Func& _func; 
     unsigned& _count; 
    }; 
} 

// generic find_if_counted, 
// returns the index of the found element, otherwise returns find_if_not_found 
const size_t find_if_not_found = static_cast<size_t>(-1); 

template <typename InputIterator, typename Func> 
size_t find_if_counted(InputIterator start, InputIterator finish, Func func) 
{ 
    unsigned count = 0; 
    find_if_counted_impl::func_counter<Func> f(func, count); 

    InputIterator result = find_if(start, finish, f); 

    if (result == finish) 
    { 
     return find_if_not_found; 
    } 
    else 
    { 
     return count - 1; 
    } 
} 

#endif 

Ejemplo:

#include "find_if_counted.hpp" 
#include <cstdlib> 
#include <iostream> 
#include <vector> 

typedef std::vector<int> container; 

int rand_number(void) 
{ 
    return rand() % 20; 
} 

bool is_even(int i) 
{ 
    return i % 2 == 0; 
} 

int main(void) 
{ 
    container vec1(10); 
    container vec2(10); 

    std::generate(vec1.begin(), vec1.end(), rand_number); 
    std::generate(vec2.begin(), vec2.end(), rand_number); 

    unsigned index = find_if_counted(vec1.begin(), vec1.end(), is_even); 

    if (index == find_if_not_found) 
    { 
     std::cout << "vec1 has no even numbers." << std::endl; 
    } 
    else 
    { 
     std::cout << "vec1 had an even number at index: " << index << 
      " vec2's corresponding number is: " << vec2[index] << std::endl; 
    } 
} 

Aunque siento que estoy haciendo algo tonto ...: X Todas las correcciones son bienvenidos, por supuesto.

Answer 7

std::vector tiene iteradores de acceso aleatorio. Puede hacer aritmética de puntero con ellos. En particular, este my_vec.begin() + my_vec.size() == my_vec.end() siempre se mantiene. Por lo que podría hacer

const vector<type>::const_iterator pos = std::find_if(firstVector.begin() 
                , firstVector.end() 
                , some_predicate(parameter)); 
if(position != firstVector.end()) { 
    const vector<type>::size_type idx = pos-firstVector.begin(); 
    doAction(secondVector[idx]); 
} 

Como alternativa, siempre hay std::numeric_limits<vector<type>::size_type>::max() para ser utilizado como un valor no válido.

Answer 8

Si un vector tiene N elementos, hay N + 1 respuestas posibles para encontrar. std :: find y std :: find_if devuelven un iterador al elemento encontrado O end() si no se encuentra ningún elemento.Para cambiar el código tan poco como sea posible, su función de búsqueda debe devolver la posición equivalente:

size_t find(const vector<type>& where, int searchParameter) 
{ 
    for(size_t i = 0; i < where.size(); i++) { 
     if(conditionMet(where[i], searchParameter)) { 
      return i; 
     } 
    } 
    return where.size(); 
} 
// caller: 
const int position = find(firstVector, parameter); 
if(position != secondVector.size()) { 
    doAction(secondVector[position]); 
} 

Me gustaría volver a utilizar std :: find_if, sin embargo.

Answer 9

Tome un vector de número entero y una clave (que encontramos en el vector) .... Ahora estamos atravesando el vector hasta encontrar el valor clave o el último índice (de lo contrario) ..... Si encontramos la clave, entonces imprima la posición, de lo contrario imprima "-1".

 #include <bits/stdc++.h> 
    using namespace std; 

    int main() 
     { 
      vector<int>str; 
      int flag,temp key, ,len,num; 

      flag=0; 
      cin>>len; 

      for(int i=1; i<=len; i++) 
      { 
       cin>>key; 
       v.push_back(key); 
      } 

      cin>>num; 

      for(int i=1; i<=len; i++) 
      { 
      if(str[i]==num) 
      { 
       flag++; 
       temp=i-1; 
       break; 
      } 
      } 

     if(flag!=0) cout<<temp<<endl; 
     else   cout<<"-1"<<endl; 
     str.clear(); 

     return 0; 
     }