Se déplacer dans un vector

Bonjour,
Je débute le CPP et je bloque sur quelque chose que je ne comprends pas.

J'ai une fonction qui récupère un vector<string> name, et je cherche un élément dedans donc je dois me déplacer à l'intérieur de mon vector. Pour ce faire j'utilise un index et j'incrémente mon vector de façon à me déplacer string par string :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 std::string Parser::findMeta(std::vector<std::string> array) { int i = 0; while (array[i]) { if (array[i].find("meta-charset")) return ("OK"); i++; } return ("NOO"); }
Cependant à la compilation j'obtiens :

Citation:

/home/untitled/parser.cpp:36: erreur : could not convert ‘array.std::vector<_Tp, _Alloc>::operator[]<std::__cxx11::basic_string<char>, std::allocator<std::__cxx11::basic_string<char> > >(((std::vector<std::__cxx11::basic_string<char> >::size_type)i))’ from ‘__gnu_cxx::__alloc_traits<std::allocator<std::__cxx11::basic_string<char> > >::value_type {aka std::__cxx11::basic_string<char>}’ to ‘bool’
while (array[i])
^

Auriez-vous une solution?
Merci

Regarde ta ligne 5 :mrgreen:

Tu as un tableau de chaînes de caractères et tu transformes une case en booléen :aie: :aie:

~~Ça m'étonne cette erreur, parce qu'~~il me semble que if(valeur_autre_qu_un_bool) est aussi bien permis en C++ qu'en C...
Je ne dis pas que c'est une bonne chose, par contre.

Edit: Ah j'avais mal lu, c'est une string d'un vecteur de strings, et non pas un char individuel d'une string. En effet, les types complexes ne sont pas implicitement convertibles en bool à moins que ce soit explicitement programmé dans la classe.

Oui mon tuteur m'a expliqué... ^^
Il m'a parlé des iterators pour me déplacer du coup je mets le sujet comme résolu, merci à vous deux !

Bonjour, il y a plein de petits soucis dans ce fragment de code.

Pour commencer, tu veux une fonction qui retourne "oui" ou "non". Il serait plus logique de retourner un bool (true ou false) et d'utiliser ce booléen pour faire ce que tu en veux.

Ta fonction ne retourne pas l'index de la recherche, mais seulement si l'élément existe. Je l'appelerai plus has que find. Comme ce qu'elle cherche n'est pas "Meta" mais "meta-charset", je choisirai plus comme nom has_charset (ou hasCharset).

Tout paramètre d'une fonction est une variable, qui est initialisée avec la valeur de l'argument donné au moment de son appel.
Ici, ton array est un vecteur. L'initialisation d'un vecteur a partir d'un autre est fait en copiant un a un chaque élément du vecteur.
C'est dommage, parce que tu pourrais passer par une référence (qui elle ne coute presque rien)

Code:

bool Parser::has_charset(std::vector<std::string> const& array);

D'un point de vue interne, l'index dans un vector n'est pas de type int, mais std::vector<std::string>::size_type.
Pour parcourir, une collection, il vaut mieux recourir à:

un algorithme
le range based for
les iterateurs

Cela dit, pour un vecteur, on peut se poser la question de la rapidité.

Pour ton soucis pratique:
Ton compilateur te dis "je ne sais pas convertir "une expression completement explicite", depuis le type "vachement long aka (qui veut dire "also known as") string" en "bool" dans la ligne de code while(array[i])C'est normal, ce n'est pas du tout le bon moyen de savoir si le nombre i est un indice valable. La condition serait i<array.size().

De même avec array[i].find("meta-charset")Ton array étant un vector<string>, array[i] est une string, et find est la fonction membre de string, qui retourne non pas un booléen, mais un string::size_type (qui vaut soit la position de la sous chaine, soit std::string::npos)

En fait, tu pourrais écrire:
Code:

1 2 3 4 5 6 bool Parser::has_charset(std::vector<std::string> const& array) { for ( std::vector<std::string>::size_type i = 0; i < array.size(); ++i) { if (array[i].find("meta-charset")!=std::string::npos) return true; } return false; }
Ici, le code est correct, les types sont respectés.

Mieux, tu peux passer par begin et end (et les const_iterator)
Code:

1 2 3 4 5 6 bool Parser::has_charset(std::vector<std::string> const& array) { for (std::vector<std::string>::const_iterator it = array.begin(); it != array.end(); ++it) { if (it->find("meta-charset")!=std::string::npos) return true; } return false; }
C'est mieux, parce que tu pourras changer vector par n'importe quelle collection standard (list, deque ou même set)

Et puis comme il existe un mot clé pratique, auto, tu peux aussi écrire
Code:

1 2 3 4 5 6 bool Parser::has_charset(std::vector<std::string> const& array) { for (auto it = array.begin(); it != array.end(); ++it) { if (it->find("meta-charset")!=std::string::npos) return true; } return false; }
L'avantage c'est que tu n'as pas à recopier le type de l'argument. Donc pas d'erreur possible.

Mais on a encore mieux (si si...), le "range based for":
Code:

1 2 3 4 5 6 bool Parser::has_charset(std::vector<std::string> const& array) { for (std::string const& s : array) { if (s.find("meta-charset")!=std::string::npos) return true; } return false; }
Ici, la magie, c'est que puisque vector est utilisable avec std::begin() et std::end(), tout est fait automatiquement.

et avec auto, c'est encore mieux.
Code:

1 2 3 4 5 6 bool Parser::has_charset(std::vector<std::string> const& array) { for (auto const& s : array) { if (s.find("meta-charset")!=std::string::npos) return true; } return false; }
Et maintenant, il y a encore plus fort: les algorithme, avec les lambdas. il suffit d'avoir #include <algorithm>
Code:

1 2 3 4 5 bool Parser::has_charset(std::vector<std::string> const& array) { return std::any_of(array.begin(), array.end(), [](std::string const& s) -> bool { return s.find("meta-charset")!=std::string::npos; } ); }
C'est franchement mieux, parce que any_of est une fonction standard, qui peut être plus optimisée que tu ne l'espère.
Oui, c'est bien cela, le troisième argument de any_of est une fonction locale.

Et la, ca devient presque magique, parce ton code n'a plus besoin explicitement du fait que array soit un vector (mais de string, si).
Du coup, on pourrait même en faire une template, mais ca n'est pas nécessaire de t'embrouiller avec ca pour le moment.