Discussion :

[olivier]]

Bonjour.

Suivant les recommandations de Luc, j'ai trouvé dans le cours C++ de Zeste de savoir le bout de code suivant

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
...
  std::string const ma_chaine {"rien ne sert de courrir, il faut partir a point"};
  auto iter_debut_mot {std::begin(ma_chaine)};
...

c'est dans le main, et il n'y a pas "using namespace std;".

Il est expliqué plus haut dans le tuto qu'avec auto, le compilateur est capable de déterminer le type de iter_debut_mot.
D'accord, mais moi, je ne sais pas le déduire.

Quelqu'un pourrait-il me dire quel est le type de iter_debut_mot et comment je dois le déclarer si je ne veux pas utiliser "auto" ?
C'est juste pour ma culture, je n'ai pas de problème de compilation ou d'exécution.

Merci d'avance de votre aide.

[Luc Hermitte]

Ici, ça sera`std::string::const_iterator` -- tu reprends le type du conteneur, et rajoute `::` plus `iterator` (si tu veux (et peux!! -> pas le cas ici à cause du `const`) permettre la modification via cet itérateur), ou `const_iterator` (si la modification ne sera pas permise)

Ce n'est pas des plus utiles. Pas des plus compliqués non -- attends les `std::map<std::string, std::vector<std::string>>::const_iterator`.

La première raison d'être d'`auto`, c'est justement pour simplifier l'écriture de ces itérateurs.

PS: mon environnement de dev (gvim ultra-configuré) me permet un clic droit pour inspecter le type ou afficher le type des diverses variables. N'importe quel VSCode (configuré avec clangd derrière le LSP) en permettra autant.

[Obsidian]

(Edit : crosspost avec Luc le temps de rédiger ce message)

Bonjour,

Effectivement, ce n'est pas simple du tout (même si, comme souvent et surtout en C++, le concept devient relativement clair une fois qu'on a compris l'idée générale).

Réponse courte :

Dans le cas qui t'intéresse, le type est std::basic_string<char>::iterator (et donc std::string::iterator).

Réponse un peu plus longue :

Les itérateurs au sens large sont un pattern qui peut s'appliquer à n'importe quel objet itérable, c'est-à-dire que l'on peut parcourir au moins en passant d'un élément au suivant. Donc, ça peut être un tableau, une chaîne de caractère, etc. mais ça peut être également le resultset d'une requête SQL en cours d'exécution, par exemple. Le fait de n'avoir besoin que d'itérer dessus te dispense d'avoir à récupérer et charger en mémoire le jeu de données entier avant de commencer à le traiter et tu peux laisser le serveur te le distiller au compte-goutte si ça l'arrange.

Pour savoir où on en est, on utilise un objet spécifique qui conserve les méta-données nécessaires. Sur un tableau, un simple pointeur suffit, comme en langage C et c'est pour cela qu'on le mappe souvent sur les mêmes opérateurs (« * » unaire, de déréférencement).

Étant donné que cet objet est spécifique, à chaque fois, à celui sur lequel il itère, il est bien souvent défini comme sous classe de l'objet concerné. Donc ici (en très simplifié) :

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
class string
{
    public:
 
    class iterator
    {
        …
    }
 
    …
}

Donc ici, on définit en une seule fois le type string et son sous-type string::iterator.

C'est ce qui se passe avec std::string, à ceci près que celle-ci est elle-même dérivée de std::basic_string<>, qui est une grosse classe template générique permettant de définir des chaînes d'à peu près n'importe quels types (caractères ou autres). std::string est en fait un alias de type sur std::basic_string<char>, parce que char est le format de caractère par défaut en vigueur en C et C++.

À présent, en dehors des types natifs, sont considérés itérables (par convention) les objets qui proposent au moins les fonctions-membres begin() et end(). L'une comme l'autre doivent renvoyer un itérateur (de même type dans les deux cas), l'un référençant le premier élément, l'autre situé exactement un pas après le dernier élément, ce afin que l'on puisse terminer la boucle lorsque l'itérateur courant est égal à celui renvoyé par end().

std::begin() et std::end, enfin, sont des fonctions template unifiées définies au niveau global et qui te permettent d'obtenir l'itérateur de n'importe quel objet déjà instancié s'il en propose et qu'il implémente les mêmes méthodes. Elle sont décrites ici : https://en.cppreference.com/cpp/iterator/begin

On voit que leur prototype exige qu'il s'agisse d'une fonction qui admette en argument un type générique C et qui renvoie une donnée dont le type est celui de C.begin() (ce qui impose qu'elle soit implémentée).

[mintho carmo]

Le type est `basic_string<char, char_traits<char>, allocator<char>>::__wrap_iter<allocator_traits<allocator<char>>::pointer>`.

Les 2 messages précédents montrent justement pourquoi c'est mieux d'utiliser `auto`.

> ça sera`std::string::const_iterator`

> et donc std::string::iterator

Ce qui compte, c'est le concept. Pas le type exact.

[olivier]]

Merci à vous 3 pour ces réponses très détaillées.

j'avais essayé std::string::iterator par ce que c'est ce qui me semblait le plus logique au vu de ce que j'ai compris.
Mais comme ça ne fonctionnait pas, je me suis tourné vers vous.
C'est bête, il ne manquait pas grand'chose

Au vu de vos explications, je comprends bien l'intérêt de auto. Mais pour pouvoir bien l'utiliser, j'ai besoin de savoir "ce qui se passe en coulisse".

Luc, je travaille avec codeblocks sous win11. Je vais tâcher de mettre en oeuvre ce dont tu parles mais ce n'est pas gagné...

Encore Merci à vous 3.

[Luc Hermitte]

C::B était pour moi un outil du passé. Visiblement il a un serveur LSP, il faut lui installer clangd en client du coup: https://wiki.codeblocks.org/index.php/CB_Clangd_Client

Et comme je disais, ta chaine est non modifiable => l'itérateur ne peut pas autoriser la modification sur la chaine => ça doit se répercuter dans le type.

A force de relectures du tuto puis de la version papier, j'avoue que je ne sais plus exactement, mais il me semble que ces choses seront abordées plus tard j'imagine.

[kaitlyn]

Salut,

Code::blocks est à la fois simple et léger, personnellement, j'aime bien.

Après, pour qui a besoin de connaître le type d'un objet, et ce, quel que soit l'EDI, il lui suffit de forcer une erreur de conversion.
Ici, par exemple, en remplaçant "auto" par "int", la compilation échouera et le message d'erreur contiendra l'information recherchée.
D'ailleurs, dans ses essais, il l'avait certainement eue, mais apparemment, sans y prêter attention.