En utilisant equal(), find() sur un vecteur <complexe <double>>

Question

C'est une chose assez simple, mais j'ai commencé à essayer de comprendre. J'essaie de comparer les éléments d'un vector<complex <double> > vec avec un complex <double> num pour vérifier si num existe déjà sur vec. Si c'est le cas, il n'est pas ajouté. J'ai essayé d'utiliser equal() et l'algorithme, sans succès. Est-ce que quelqu'un connaît un moyen rapide de faire cela?

EDIT2: Je suis en train de le faire pour les nombres complexes comme une simplification, comme je l'ai aussi besoin d'effectuer la même opération sur une struct:

struct thing{ 
int i; 
int j; 
complex <double> pos; 
}typedef t_thing; 

complex <double> new_num(2.0,2.0); 
t_thing will_insert; 
will_insert.i = 1; 
will_insert.j = 1; 
will_insert.pos = new_num; 
vector<t_thing> vec_thing; 
if(! (find(vec_thing.begin(),vec_thing.end(),will_insert) == vec_thing.end())){ 
    vec_thing.push_back(will_insert); 
}else { 
cout<<"element already on vec_thing"<<endl; 
} 

EDIT 3: J'ai surcharge l'opérateur ==, mais ne peut trouver que travailler avec:

: error: no matching function for call to ‘find(__gnu_cxx::__normal_iterator<thing*, std::vector<thing, std::allocator<thing> > >, __gnu_cxx::__normal_iterator<thing*, std::vector<thing, std::allocator<thing> > >, t_thing&)’ 

Answer 1

l'algorithme std::equal est utilisé pour comparer 2 gammes de iterator. Vous l'utiliserez donc pour comparer, par exemple, 2 vecteurs pour voir si les deux vecteurs contiennent les mêmes éléments.

Dans votre cas, où il vous suffit de vérifier si un seul élément est à l'intérieur du vecteur, vous pouvez simplement utiliser std::find

if (std::find(vec.begin(), vec.end(), std::complex<double>(1,1)) == vec.end()) { 
    /* did not find element */ 
} 
else { /* found the element */ } 

Notez cependant que std::vector n'est pas particulièrement bien adapté pour les algorithmes de recherche comme cela, puisque chaque recherche vous donne la complexité O (N). Vous pouvez envisager d'utiliser std::set, vous obtenez ainsi une complexité logarithmique pour la recherche, et l'assurance automatique que vous n'avez aucun élément en double.