Discussion :

[Lightness1024]

je suis vraiment désolé de ne pas prendre le temps de lire les 4 pages, donc surement que ce que je dis a déjà été mentionné.
mais pour répondre a l'OP:

1: pourquoi pas tant que faisable et ne termine pas en un code plus long et dispersé a lire
2: "systématique" c'est bien le problème dans ton topic Mr gbdivers. je ne vois pas comment la STL peut fournir tous les algorithmes du monde. évidemment que c'est impossible.
3: excellent, il faudrait plus de ce genre de méthodes chez les profs. rentrer dans la tête des ptis bleus que réinventer la roue carrée saymal.
4: non. désolé je ne le pense vraiment pas. parfois écrire un for en 3 lignes c'est plus clair qu'appeller un algo avec des itérateurs de partout qui fait une ligne de 160 caractère de long avec du begin() et end() a n'en plus finir.
5: a mon avis il y en a une infinité

- pour rajouter un peu de mon avis perso, je ne connais pas d'implémentation des algos STL qui tourne en multi-thread. avec un for en 2 secondes tu fais #pragma parallel for.
ou alors tu peux utiliser les libs SIMD d'intel, ou meme Trust pour faire tourner des algos en CUDA.

- écrire un transform avec le code déporté a 15km dans une structure, voire meme dans un autre fichier (car certaines coding rules disent 'une classe=un fichier') c'est ridicule. C++11 règle ce problème avec les lambdas, ce n'est pas pour rien.

et franchement je peux continuer comme ca longtemps, tu me dirais bannir for(;;) au profit de while() je dirais ok car for n'est pas une structure de contrôle standard en algorithmique, alors que while() l'est.
mais bannir au profit de la STL c'est juste pas possible, la STL ne fourni pas tout.

voila désolé de rompre le fil du topic

[shenron666]

Tu prends un exemple de code minimaliste, où l'on a besoin d'avoir l'indice, on reste donc sur de la boucle for quasiment classique. Il y a quand même beaucoup d’algorithmes qui n'ont pas besoin de connaître i

l'inverse est aussi vrai : il y a beaucoup d'algorithmes qui ont besoin de connaitre l'index

(et pour rappel, [] n'est pas ce qu'il y a de plus performant en terme d'accès)

moins performant que n'importe quel algorithme de la stl ? j'en doute

Donc dans tous les cas, il faudra créer cette variable, ce qui ne permet pas de réduire proprement le code

d'où mon exemple qui démontre si besoin en était que supprimer for serait contre productif

en fait, c'est juste un faux débat
ou alors on supprime aussi while et on retourne au goto

[tasna]

Personnellement j'utilise les boucles while 99% du temps. Viennent ensuite les boucles do-while à 0.9% et les for à 0.1%.

J'allais écrire "Les boucles while sont hyper simples".
Non toutes les boucles sont simples mais je préfère les boucles while parce que j'aime la représentation.

C'est à dire que je préfère voire ça :

Code :

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

1
2
3
4
5
6
7
 
int LineIx=0;
int LineLen=strlen(Line);
while(LineIx!=LineLen)
{
     ++LineIx;
}

que ça :

Code :

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

1
2
3
4
5
6
 
int LineLen=strlen(Line);
for(int LineIx=0; LineIx<LineLen; LineIx++)
{
     //
}

Je préfère les boucles while parce que dans les boucles for on a un tas d'informations collées et ça peut-être contraignant à lire pour ceux qui utilisent une police de caractères assez petite.

Et puis je préfère séparer les choses. Déclarer d'un côté, tester de l'autre et incrémenter à part.

Après ça dépend des personnes. Certaines peuvent lire et comprendre plus vite des lignes avec pleins d'informations tandis que certaines préfèrent le code avec plus de lignes mais de petite taille.

La seule raison pour laquelle je me mettrai au boucles for c'est si il est prouvé qu'elles s'exécutent plus rapidement.

[Bousk]

Code :

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

1
2
3
4
5
6
7
8
 
for(int LineIx=0,
         LineLen = strlen(Line);
     LineIx < LineLen;
     ++LineIx)
{
     //
}

La lisibilité, ça se cherche/trouve.

[guigz2000]

Bannir le for du C++?
LOL....Plus serieusement,Non...

Plusieurs raisons:
1..Le for est une construction intrinseque au language.La STL en revanche est une librairie.Comme toute librairie elle peux etre changée et evoluer alors que le for classique ne changera pas. En plus sur certain compilateurs a la noix, la STL n'est pas toujours parfaitement supportée ou implementée.

2..J'aimerai bien voir un microbenchmark d'une boucle for et d'un equivalant STL.Je doute que au niveau performance cela soit vraiment similaire

3..Au niveau complexité, remplacer un élément de language par une librairie a tendance a me hérisser le poil,sauf si on attends une fonctionnalité bien spécifique et vraiment plus complexe.Cela aura tendance systematiquement a générer un microcode moins compact et plus lourd a l'execution.Meme si un compilateur optimise bien cela aura dans tous les cas une incidence sur la taille et la vitesse du code.Un algo reste un algo et il est souvent implementé lui meme avec des boucles for,while,etc...Il utilise des variables supplementaire, occupe de la memoire et contient troutes sortes de tests pas forcements necessaire pour l'utilisation voulue.En plus,un appel de fonction n'as jamais de consequences nulles au niveau performances.

4.. Pour ce qui est de la facilité de lecture, un commentaire expliquant une boucle for un peu complexe est souvent suffisant.

J'ai vraiment l'impression que dans la plupart des cas,utiliser la STL pour remplacer des constructions simples (dans ce cas une boucle for) reviens vraiment a utiliser un marteau pour tuer une mouche.Ca marche mais on prends le risque de se taper sur les doigts ou d'avoir une tendinite.

[ManusDei]

Je ne comprend pas la question. Je pourrais avoir un exemple (avec for, sans for) ?

[kolodz]

Ces méthode sont un support à la gestion des listes/collections.

Bon exemple serai donc :

Code :

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

1
2
3
4
5
6
iterator i = find (c.begin(), c.end(), value);
// is the same as
iterator i;
for ( i=c.begin(); i!=c.end(); ++i ) {
  if (*i==value) break;
}

C'est en effet plus clair. Sur d'autre langage, ce genre de méthode existe.
Mais on ne considère pas cela comme un remplacement du "for".

D'ailleurs, un langage qui ne dispose pas d'un find "standard". Il sera probablement crée une fonction réalisant l'opération, par le développeur.*

Cordialement,
Patrick Kolodziejczyk.

[bugsan]

Réponse: method extract + nommer correctement cette méthode.

[themadmax]

Je partage un peu aussi cet avis. Un aglo de la STL est tellement plus sexy qu'un for. Mais dans la vrai vie, l'utilisation des foncteurs déclaré comme une struct à l’extérieur de la fonction courante sont très lourd, parfois extrêmement compliqué ( appel sur un vecteur de pointeur vers une fonction membre de l'objet). Après la dernière version de C++ permet peut-être cela plus simplement.

Pour info Microsoft à implémenté un SQL like (LINQ) pour remplacé les for, mais je trouve ce mélange C#/SQL vraiment sale.

Un autre probleme qui m'arrive, lorsque l'on fait une boucle avec le besoin d'avoir un identifiant (la valeur de i), j'ai parfois utilisé std::distance() pour la calculé mais la boucle for dans ce cas correspond finalement mieux aux besoins.

[clavier12AZQSWX]

avec les boucles FOR, une chose est certaines :
NE JAMAIS mettre la condition dans la syntaxe boucle mais toujours en dehors !

ne jamais faire :

Code :

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

1
2
for (a=1;a<count(mavariable);a++)
{...}

mais toujours

Code :

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

1
2
3
borne=count(mavarialbe)
for (a=1;a<borne;a++)
{...}

sinon suivant la taille du tableau, la mémoire est constament réutilisée, recachée,estimée...

bref une énorme perte de temps, de ressources et de performance !

Avis aux codeurs fous du PHP et de python !

[Invité]

pour ma part iterer sur un tableau avec du size_t i=0, ca me choque pas.
Pas plus que sur un string avec l'operateur []

Je prefere ca, parce que declarer des iterators (mine de rien), ca prend de la place.
Jaime pas declarer en dehors de ma boucle (prob de scope) et j'aime pas gaspiller des lignes (accolades de scope, +declaration de literateur). Et ca tient pas a l'interieur de la boucle for...si on code en 80 caracteres.

Bref, pour les array et structure avec operator[] (string, deque,...) je prefere utilise la bonne vieille incrementation, et je ne crois pas quon perde en semantique. Au contraire...

[clavier12AZQSWX]

Je prefere ca, parce que declarer des iterators (mine de rien), ca prend de la place.
Jaime pas declarer en dehors de ma boucle (prob de scope) et j'aime pas gaspiller des lignes (accolades de scope, +declaration de literateur). Et ca tient pas a l'interieur de la boucle for...si on code en 80 caracteres.

Programmeur........

Didonc, si on te demande de faire 50000 fois le tour d'une place et de compter à chaque fois le nombre d'ordure dans les poubelles, ça te plaîrait ?
Si tu sais qu'à chauqe tour de place, personne n'a mis ou vider de poubelle, est-ce que tu vas recompter ? non ? alors pourquoi tu le fais (en mettrant ton compteur dans la boucle for) c'est une perte de temps énorme.

[Bousk]

@Michael remy, je n'ai strictement rien compris de tes 2 dernières contributions...

Code :

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

1
2
3
borne=count(mavarialbe)
for (a=1;borne<10;a++)
{...}

il y a plus simple pour réaliser une boucle infinie
a < borne plutôt non ?
ou ta boucle se charge de décrémenter borne ?
tout cela n'est pas clair

Tous les getSize() de la stl sont const et en temps constants, la "seule perte" c'est l'appel supplémentaire.
Et dans ce cas on privilégiera cette écriture amha

Code :

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

for (int i = 0, t = vec.size(); i < t; ++i) {}

[Invité]

Je ne crois pas qu'on puisse parler des algorithmes de la STL comme d'un tout.

J'ai l'impression qu'il y a en fait quatre catégories très différentes :

1- des templates de fonctions très utilisées (min, max, swap)
2- des fonctions de librairie standard utilisant le modèle des conteneurs et des itérateurs (copy, filll, remove, erase, find)
3- des algorithmes au sens habituel du terme (sort, partition, stable_sort, les opérations sur ensembles binaires)
4- un assemblage de méthodes permettant une progammation générico-fonctionnelle (transform, bind, inner_product,...)

Personnellement, j'ai tendance à utiliser souvent le groupe 1. Ce sont des algorithmes triviaux, qui n'apportent rien au code, mais ça devient vite une habitude.

Je me méfie du groupe 2: en général, les opérations efficaces d'un conteneur sont implémentées comme des fonctions membres, et les algorithmes "standard" ont une furieuse tendance à devenir sous-optimaux quand on fait évoluer les conteneurs sous jacents.

J'utilise systématiquement le groupe 3, mais suis toujours étonné par le nombre de programmeurs qui ne comprennent pas la différence entre sort et stable_sort, ou quand il faut utiliser partition, ou comment on utilise sort pour indexer des données qu'on ne veut pas trier.

La catégorie 4, où se trouvent la plupart des fonctions pouvant éliminer les boucles, m'a toujours parue suspecte. D'abord parce que je ne crois pas qu'un for_each() soit plus expressif qu'un for(; ; ). Pour des boucles "normales" (c'est à dire de quelques lignes, quelques dizaines au plus), qui ne sont utilisées qu'une fois (ou tellement courte qu'il n'est pas nécessaire de les centraliser) je préfère nettement voir, quand je débugue, la boucle dans son contexte que de jouer au "code dont vous êtes le héros", en sautant d'une fonction à l'autre (voire d'un foncteur à l'autre, avec leurs constructeurs, leurs surcharges, etc.). Aussi, parce que dans du code existant, majoritairement non fonctionnel, cette approche complique gratuitement l'existant (je ne l'ai jamais vue simplifier le code, en pratique), et que si le but est d'écrire en fonctionnel, je choisirais d'autres langages (le J dans mon cas).

Francois

[Invité]

Programmeur........

Didonc, si on te demande de faire 50000 fois le tour d'une place et de compter à chaque fois le nombre d'ordure dans les poubelles, ça te plaîrait ?
Si tu sais qu'à chauqe tour de place, personne n'a mis ou vider de poubelle, est-ce que tu vas recompter ? non ? alors pourquoi tu le fais (en mettrant ton compteur dans la boucle for) c'est une perte de temps énorme.

peux-tu développer avec un exemple concret plutot qu'une analogie foireuse? Parce que si on me demande de compter, moi je compte.

J'ai l'impression qu'il y a en fait quatre catégories très différentes :

je ne fais aucune différence entre la catégorie 1 (que tu utilises au plus) et la catégorie 4 (qui te rebute). Pour moi, c'est que des fonctions "globales" que je n'utilise que si la doc est bien détaillée, et que la fonction est livrée dans un "tout" a peu pres utile.

Quant au for_each, je l'aime bien. Je suis incapable de m'en passer en js, ou php (et même en java quand j'eus été contraint d'utiliser ce langage). Mais bon, en c++, foreach, des que y a quelques itérateurs qui se courent après, c'est la déclaration au dessus, donc au final ca sert à rien je trouve (je parle pour boost_foreach)

[clavier12AZQSWX]

@Michael remy, je n'ai strictement rien compris de tes 2 dernières contributions...

Code :

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

1
2
3
borne=count(mavarialbe)
for (a=1;borne<10;a++)
{...}

il y a plus simple pour réaliser une boucle infinie
a < borne plutôt non ?
ou ta boucle se charge de décrémenter borne ?
tout cela n'est pas clair

Tous les getSize() de la stl sont const et en temps constants, la "seule perte" c'est l'appel supplémentaire.
Et dans ce cas on privilégiera cette écriture amha

Code :

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

for (int i = 0, t = vec.size(); i < t; ++i) {}

merci de m'avoir fait remarquer mon erreur ! j'ai corrigé mes exemples !

[alex.buisson]

C++11 introduit le for_each comme un element du langage, de plus les extensions begin et end fournissent des iterateur autant pour la STL que pour les tableaux et autres zones mémoires allouées par malloc ou new.

Donc à mon sens, il s'agit d'une pratique a enseigner car la STL et les lambda prennent de plus en place....

[K-LiBR3]

Ce sont de très bonnes pratiques, mais attention, pour les algos de type "recherche du plus court chemin" par exemple, la library standard complexifie le code en terme de ressources processeur : il est préférable de faire ses propres boucles et structures (expérience personnelle, je suis passé d'une exécution en une journée à 15 secondes...).
Après on peut toujours choisir LA bonne structure standard, mais il y aura à coup sure quelques traitements non prévus... et ça fait mal !

[air-dex]

D'un point de vue pédagogique, que pensez-vous de cet exercice ?

Excellent dans le cadre de l'apprentissage de la STL. Et puis c'est bon pour ce qui est de ne pas réinventer la roue.

Que pensez-vous de cette attitude de supprimer, sauf choix conscient et justifié, les boucles for du code au profit de la STL ?
Dans un cadre professionnel, pensez-vous que cette règle soit utile ? Applicable ?

Pour que l'idée soit bonne, il faudrait que TOUS les développeurs C++ aient un très bon niveau en STL. Or ce n'est pas le cas. Il y a tous les débutants C++ qui seraient largués avec toutes les fonctions et méthodes standards qu'ils ne connaissent pas, mais aussi les habitués à d'autres librairies (Boost, Qt, librairies de Microsoft par exemple) à qui il manquerait de la pratique de la STL et donc des connaissances dessus.

Prenons l'exemple au stagiaire débutant encore à l'école qui débarque dans l'équipe de développement. Bien sûr, il n'est pas un pro de la STL même si ses cours dessus sont encore relativement frais dans sa tête. Il va passer son temps sur http://www.cplusplus.com à comprendre les algorithmes utilisés dans le code et à chercher ceux qu'il va devoir utiliser puisqu'on lui a proscrit la boucle for. Paye ta productivité !

Je pourrais également citer ma faible expérience en Qt. Elle m'a montré qu'il vaut mieux utiliser les structures de QtCore plutôt que celles de la STL dans un programme Qt (QString au lieu de std::string, QMap au lieu de std::map, etc.). Et ce même s'il existe certaines passerelles entre la "STL standard" et la "STL de Qt" (QtCore). Le problème avec ça, c'est que la STL je ne la pratique pas et je l'oublie.

***

Et puis rien n'empêche de contourner l'interdiction avec un bon vieux while des familles :

Code C++ :

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

1
2
3
4
5
int i = 0;
while (i < N) {
    doSthg();    // Le code de la boucle
    i++;
}

[Invité]

Il va passer son temps sur http://www.cplusplus.com à comprendre les algorithmes utilisés dans le code et à chercher ceux qu'il va devoir utiliser puisqu'on lui a proscrit la boucle for. Paye ta productivité !

cette phrase me révolte.
Déjà le stagiaire, il est là aussi pour apprendre. Donc lui faire endosser la part de productivité, c'est un peu gros.
En plus, il est parfois bien plus compétent que les employés techniquement parlant.
Et enfin même un employé lambda est aussi là pour apprendre. Après qu'il s'en tape c'est une autre affaire.

Quant à Qt, ca me semble normal de préférer l'utilisation des structures de Qt pour Qt avant l'emploi de la stl...

mais sinon, je suis d'accord avec le bon vieux while, c'est pas joli etc, mais c'est simple et concis.