Au fait, si tu appelles ton objet "iterator", il vaudrait
mieux lui mettre des opérateurs ++ et -- au lieu de next() et
prev().
Ça se discute. L'utilisation de next() et de prev() est bien
plus compréhensible.
Au fait, si tu appelles ton objet "iterator", il vaudrait
mieux lui mettre des opérateurs ++ et -- au lieu de next() et
prev().
Ça se discute. L'utilisation de next() et de prev() est bien
plus compréhensible.
Au fait, si tu appelles ton objet "iterator", il vaudrait
mieux lui mettre des opérateurs ++ et -- au lieu de next() et
prev().
Ça se discute. L'utilisation de next() et de prev() est bien
plus compréhensible.
Pour être plus clair, voici le cas qui m'interesse plus particulierement :
nous avons une classe "iterator" qui me permet d'itérer sur une structure de
donnée. Un "iterator" a de bonnes raisons (qui ne sont pas discutables :))
d'être un peu lourd à copier.
Pour être plus clair, voici le cas qui m'interesse plus particulierement :
nous avons une classe "iterator" qui me permet d'itérer sur une structure de
donnée. Un "iterator" a de bonnes raisons (qui ne sont pas discutables :))
d'être un peu lourd à copier.
Pour être plus clair, voici le cas qui m'interesse plus particulierement :
nous avons une classe "iterator" qui me permet d'itérer sur une structure de
donnée. Un "iterator" a de bonnes raisons (qui ne sont pas discutables :))
d'être un peu lourd à copier.
On 9 Jan 2006 01:30:06 -0800, "kanze" :Au fait, si tu appelles ton objet "iterator", il vaudrait
mieux lui mettre des opérateurs ++ et -- au lieu de next()
et prev().
Ça se discute. L'utilisation de next() et de prev() est bien
plus compréhensible.
Après être tombé sur le même type de cas il y a quelques
minutes, je me permets de te contredire.
J'ai une classe "itérateur", avec un opérateur ++ pour
avancer, et une fonction membre "GetNext() const" qui renvoie
l'itérateur suivant.
L'opérateur ++, on sait qu'il modifie l'objet -- donc, à la
lecture du code utilisateur, on sait au premier coup d'oeil
qu'il y a modification.
Une fonction "Get...()" ne modifie pas l'objet -- typiquement,
une telle fonction est toujours const. Idem, à la lecture du
code utilisateur, on sait au premier coup d'oeil qu'il y a
modification.
Par contre, en voyant une fonction "next()" tout court, on est
généralement obligé d'aller voir la définition de la classe
pour savoir si elle modifie quelque chose ou pas.
On 9 Jan 2006 01:30:06 -0800, "kanze" <kanze@gabi-soft.fr>:
Au fait, si tu appelles ton objet "iterator", il vaudrait
mieux lui mettre des opérateurs ++ et -- au lieu de next()
et prev().
Ça se discute. L'utilisation de next() et de prev() est bien
plus compréhensible.
Après être tombé sur le même type de cas il y a quelques
minutes, je me permets de te contredire.
J'ai une classe "itérateur", avec un opérateur ++ pour
avancer, et une fonction membre "GetNext() const" qui renvoie
l'itérateur suivant.
L'opérateur ++, on sait qu'il modifie l'objet -- donc, à la
lecture du code utilisateur, on sait au premier coup d'oeil
qu'il y a modification.
Une fonction "Get...()" ne modifie pas l'objet -- typiquement,
une telle fonction est toujours const. Idem, à la lecture du
code utilisateur, on sait au premier coup d'oeil qu'il y a
modification.
Par contre, en voyant une fonction "next()" tout court, on est
généralement obligé d'aller voir la définition de la classe
pour savoir si elle modifie quelque chose ou pas.
On 9 Jan 2006 01:30:06 -0800, "kanze" :Au fait, si tu appelles ton objet "iterator", il vaudrait
mieux lui mettre des opérateurs ++ et -- au lieu de next()
et prev().
Ça se discute. L'utilisation de next() et de prev() est bien
plus compréhensible.
Après être tombé sur le même type de cas il y a quelques
minutes, je me permets de te contredire.
J'ai une classe "itérateur", avec un opérateur ++ pour
avancer, et une fonction membre "GetNext() const" qui renvoie
l'itérateur suivant.
L'opérateur ++, on sait qu'il modifie l'objet -- donc, à la
lecture du code utilisateur, on sait au premier coup d'oeil
qu'il y a modification.
Une fonction "Get...()" ne modifie pas l'objet -- typiquement,
une telle fonction est toujours const. Idem, à la lecture du
code utilisateur, on sait au premier coup d'oeil qu'il y a
modification.
Par contre, en voyant une fonction "next()" tout court, on est
généralement obligé d'aller voir la définition de la classe
pour savoir si elle modifie quelque chose ou pas.
Pour être plus clair, voici le cas qui m'interesse plus
particulierement : nous avons une classe "iterator" qui me
permet d'itérer sur une structure de donnée. Un "iterator" a
de bonnes raisons (qui ne sont pas discutables :)) d'être un
peu lourd à copier.
Tu devrais suivre les paradigmes de la bibliothèque standard de C++.
Elle introduit déjà un concept d'itérateurs réutilisables,
avec nombre d'algorithmes et autres outils très pratiques.
Pour être plus clair, voici le cas qui m'interesse plus
particulierement : nous avons une classe "iterator" qui me
permet d'itérer sur une structure de donnée. Un "iterator" a
de bonnes raisons (qui ne sont pas discutables :)) d'être un
peu lourd à copier.
Tu devrais suivre les paradigmes de la bibliothèque standard de C++.
Elle introduit déjà un concept d'itérateurs réutilisables,
avec nombre d'algorithmes et autres outils très pratiques.
Pour être plus clair, voici le cas qui m'interesse plus
particulierement : nous avons une classe "iterator" qui me
permet d'itérer sur une structure de donnée. Un "iterator" a
de bonnes raisons (qui ne sont pas discutables :)) d'être un
peu lourd à copier.
Tu devrais suivre les paradigmes de la bibliothèque standard de C++.
Elle introduit déjà un concept d'itérateurs réutilisables,
avec nombre d'algorithmes et autres outils très pratiques.
Même quand ils vont à l'encontre des bons principes de
programmation en général ? Tout dans la bibliothèque standard
n'est pas parfait.
Le choix du nom « itérateur » pour les « pseudo-pointeurs »
de
la STL est malheureux ; le concepte d'itérateur existait bien
avant, pour quelque chose de légèrement différent.
Même quand ils vont à l'encontre des bons principes de
programmation en général ? Tout dans la bibliothèque standard
n'est pas parfait.
Le choix du nom « itérateur » pour les « pseudo-pointeurs »
de
la STL est malheureux ; le concepte d'itérateur existait bien
avant, pour quelque chose de légèrement différent.
Même quand ils vont à l'encontre des bons principes de
programmation en général ? Tout dans la bibliothèque standard
n'est pas parfait.
Le choix du nom « itérateur » pour les « pseudo-pointeurs »
de
la STL est malheureux ; le concepte d'itérateur existait bien
avant, pour quelque chose de légèrement différent.
Même quand ils vont à l'encontre des bons principes de
programmation en général ? Tout dans la bibliothèque
standard n'est pas parfait.
C'est pourtant son but.
Tout un comité a planché dessus pour faire en sorte qu'elle
soit la mieux possible.
Il est vrai néanmoins que les démarches de standardisation
sont assez lentes donc il se peut que ça ne prend pas encore
en compte certains aspects spécifiques.
Néanmoins les approches retenues sont a priori celles qui
apportent les meilleurs compromis.
Le choix du nom « itérateur » pour les « pseudo-pointeurs »
Les itérateurs ne font que surchager l'opérateur de
déréferencement (*) pour fournir l'élément courant et les
opérateurs d'incrémentation pour passer aux éléments suivants
ou précédents (en fonction de s'il s'agit d'un itérateur
bidirectionnel ou non) Ce ne sont pas des pointeurs, même si
les pointeurs sont des genres d'itérateurs dans le cas des
tableaux.
de la STL est malheureux ; le concepte d'itérateur existait
bien avant, pour quelque chose de légèrement différent.
Encore heureux que ça existait avant. L'itération c'est un des
principe de la programmation impérative.
Et quelle est cette différence dont tu parles ?
Même quand ils vont à l'encontre des bons principes de
programmation en général ? Tout dans la bibliothèque
standard n'est pas parfait.
C'est pourtant son but.
Tout un comité a planché dessus pour faire en sorte qu'elle
soit la mieux possible.
Il est vrai néanmoins que les démarches de standardisation
sont assez lentes donc il se peut que ça ne prend pas encore
en compte certains aspects spécifiques.
Néanmoins les approches retenues sont a priori celles qui
apportent les meilleurs compromis.
Le choix du nom « itérateur » pour les « pseudo-pointeurs »
Les itérateurs ne font que surchager l'opérateur de
déréferencement (*) pour fournir l'élément courant et les
opérateurs d'incrémentation pour passer aux éléments suivants
ou précédents (en fonction de s'il s'agit d'un itérateur
bidirectionnel ou non) Ce ne sont pas des pointeurs, même si
les pointeurs sont des genres d'itérateurs dans le cas des
tableaux.
de la STL est malheureux ; le concepte d'itérateur existait
bien avant, pour quelque chose de légèrement différent.
Encore heureux que ça existait avant. L'itération c'est un des
principe de la programmation impérative.
Et quelle est cette différence dont tu parles ?
Même quand ils vont à l'encontre des bons principes de
programmation en général ? Tout dans la bibliothèque
standard n'est pas parfait.
C'est pourtant son but.
Tout un comité a planché dessus pour faire en sorte qu'elle
soit la mieux possible.
Il est vrai néanmoins que les démarches de standardisation
sont assez lentes donc il se peut que ça ne prend pas encore
en compte certains aspects spécifiques.
Néanmoins les approches retenues sont a priori celles qui
apportent les meilleurs compromis.
Le choix du nom « itérateur » pour les « pseudo-pointeurs »
Les itérateurs ne font que surchager l'opérateur de
déréferencement (*) pour fournir l'élément courant et les
opérateurs d'incrémentation pour passer aux éléments suivants
ou précédents (en fonction de s'il s'agit d'un itérateur
bidirectionnel ou non) Ce ne sont pas des pointeurs, même si
les pointeurs sont des genres d'itérateurs dans le cas des
tableaux.
de la STL est malheureux ; le concepte d'itérateur existait
bien avant, pour quelque chose de légèrement différent.
Encore heureux que ça existait avant. L'itération c'est un des
principe de la programmation impérative.
Et quelle est cette différence dont tu parles ?
Le modèle itérateur, dans les modèles de conceptions (« Design
Patterns »), est un objet -- un seul.
Dans la mesure où un itérateur n'est ni un
type arithmétique, ni un pointeur, on ne lui surcharge pas
d'opérateurs.
Le modèle itérateur, dans les modèles de conceptions (« Design
Patterns »), est un objet -- un seul.
Dans la mesure où un itérateur n'est ni un
type arithmétique, ni un pointeur, on ne lui surcharge pas
d'opérateurs.
Le modèle itérateur, dans les modèles de conceptions (« Design
Patterns »), est un objet -- un seul.
Dans la mesure où un itérateur n'est ni un
type arithmétique, ni un pointeur, on ne lui surcharge pas
d'opérateurs.
Le modèle itérateur, dans les modèles de conceptions
(« Design Patterns »), est un objet -- un seul.
Oui, bah c'est bien un objet aussi, tout itérateur de la STL
dérivant de la classe std::iterator<> (enfin il se peut que ce
soit un pointeur directement en effet)
C'est la distinction entre l'objet à itérer et l'itérateur qui
te gêne ? (référence à "un seul", je vois pas trop ce que tu
veux dire)
Dans la mesure où un itérateur n'est ni un type
arithmétique, ni un pointeur, on ne lui surcharge pas
d'opérateurs.
Depuis quand c'est mal de surcharger les opérateurs pour les
objets ?
Faire it++ et it.next() c'est la même chose, c'est juste une
histoire de syntaxe.
Le modèle itérateur, dans les modèles de conceptions
(« Design Patterns »), est un objet -- un seul.
Oui, bah c'est bien un objet aussi, tout itérateur de la STL
dérivant de la classe std::iterator<> (enfin il se peut que ce
soit un pointeur directement en effet)
C'est la distinction entre l'objet à itérer et l'itérateur qui
te gêne ? (référence à "un seul", je vois pas trop ce que tu
veux dire)
Dans la mesure où un itérateur n'est ni un type
arithmétique, ni un pointeur, on ne lui surcharge pas
d'opérateurs.
Depuis quand c'est mal de surcharger les opérateurs pour les
objets ?
Faire it++ et it.next() c'est la même chose, c'est juste une
histoire de syntaxe.
Le modèle itérateur, dans les modèles de conceptions
(« Design Patterns »), est un objet -- un seul.
Oui, bah c'est bien un objet aussi, tout itérateur de la STL
dérivant de la classe std::iterator<> (enfin il se peut que ce
soit un pointeur directement en effet)
C'est la distinction entre l'objet à itérer et l'itérateur qui
te gêne ? (référence à "un seul", je vois pas trop ce que tu
veux dire)
Dans la mesure où un itérateur n'est ni un type
arithmétique, ni un pointeur, on ne lui surcharge pas
d'opérateurs.
Depuis quand c'est mal de surcharger les opérateurs pour les
objets ?
Faire it++ et it.next() c'est la même chose, c'est juste une
histoire de syntaxe.
