string comme parametre constant dans une fonction

je veux passer à travers une string (sans la modifier) pour extraire certaines infos
le code suivant compile:

Code:

---

1 2 3 4

bool verifyString (string theString) { string::iterator start = theString.begin(); string::iterator end = theString.end(); while (start < end) {... start++ ...}

---

par contre si j'indique que je passe une string constante dans la fonction:
bool verifyString (const string theString) {...

le compilateur m'indique:
error: conversion from ‘std::basic_string<char>::const_iterator ... to non-scalar type ...

Donc le compilateur considère que j'essaie de modifier une constante en utilisant un iterator!
Pourquoi ?
Est-ce mieux de faire une copie?, d'utiliser une boucle avec un size_t: for (int i = 0; i < theString.length(); i++)...
ou de ne pas passer la string comme constante?

Parce que tu utilises un iterator et pas un const_interator. Il te le mentionne même..
Btw, le paramètre gagnerait à être const&

Bonjour,

Moi-même en apprentissage, je peux peut-être aider un peu.
Ce dont Bousk parle laconiquement, c'est de const-correctness.
D'ailleurs, une entrée un peu détaillée ne serait pas de trop dans la FAQ, à moins que je sois passé à travers sans la voir.

Ce qu'il faut retenir, à mon sens, c'est qu'à chaque fois (et il faut bien se discipliner) qu'une référence-pointeur-objet-attribut-whatever ne doit pas changer (est simplement lu ou copié), il FAUT le déclarer const. De même, une méthode ne changeant pas les attributs de l'objet DOIT être déclarée const.

Une fois qu'on s'y est habitué (ou qu'on en a compris la philosophie), ça vient naturellement.

http://cpp.developpez.com/faq/cpp/?p...-a-ma-fonction

Il me semble que si j'indique:

Code:

---

bool verifyString (string theString) {...}

---

La fonction fait une copie de la variable qui peut être utilisée et modifiée localement.
Par contre, si j'indique

Code:

---

bool verifyString (const string theString) {...}

---

alors même localement je ne peux pas modifier la variable!
Je ne vois pas en quoi mon code devient plus sécuritaire
étant donné que la variable passée en paramètre ne changera pas de toute façon!
ex: verifyString(uneAutreChaine); // uneAutreChaine ne vas pas pouvoir être modifiée dans la fonction.

D'autre part si j'écris

Code:

---

bool verifyString (string& theString) {...}

---

alors dans la fonction j'obtiens une référence à la variable
et cette fois je peux modifier la variable (ex: uneAutreChaine) dans la fonction
ce que je veux éviter.

C'est pourquoi dans ce cas je devrais faire comme l'indique Bousk

Code:

---

bool verifyString (const string& theString) {...}

---

Ainsi je ne fais pas de copie inutile d'une variable et cette variable ne peut être
modifiée dans la fonction.

Ai-je bien compris? Si oui, alors si je fais une copie locale comme dans mon premier exemple,
je ne vois toujours pas pourquoi je dois utiliser un iterator constant!

Oui, tu as bien compris. Mais j'ai bien l'impression que l'erreur n'est pas dans les lignes montrées.

Tronquer les erreurs, c'est mal ! Quelle est l'erreur complète ?

Une des règles du C++ est que l'on ne peut pas appeler de méthode non constante sur un objet constant.

Quand tu regard la documentation de std::string::begin()
http://www.cplusplus.com/reference/string/string/begin/
Tu remarque deux définitions l'une constante et l'autre non constante qui se distingue par le type de retour.

Tu dois faire appel à la méthode constante (un exemple ci-dessous) :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

#include <iostream> #include <string>   void showString (const std::string& str) { for ( std::string::const_iterator it=str.begin(); it!=str.end(); ++it) { std::cout << *it; } std::cout << '\n'; }     int main () { std::string str ("Test string");   showString(str);   return 0; }

---

Pour rendre tous çà plus simple tu peut utiliser une nouveauté du c++11 le mot-clef auto.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

#include <iostream> #include <string>   void showString (const std::string& str) { for ( auto it=str.begin(); it!=str.end(); ++it) { std::cout << *it; } std::cout << '\n'; }     int main () { std::string str ("Test string");   showString(str);   return 0; }

---

En espérant ne pas avoir dis trop de bêtise...

Encore mieux: boucle sur intervalle (for (auto & c : str) { std::cout << c; }).

Avec auto, il faut plutôt utiliser cbegin().

Ce n'est pas obligatoire ici, comme str est passé par référence sur membre constant, ce sera bien la version const de .begin() qui sera appelée.
Cependant, .cbegin() est une bonne pratique à utiliser ici aussi.

Pour la boucle basé sur un intervalle, on peut aussi utiliser const : for (auto const & c : str) { std::cout << c; }.
Et comme il s'agit d'un type primitif, la référence n'offre pas de gain (normalement) : for (char const c : str) { std::cout << c; } // Je n'utilise pas auto pour voir facilement qu'il s'agit d'un type primitif.