Discussion :

[adrbessy]

Bonjour,

Je débute sous C.
J'ai du mal à comprendre comment fonctionne la boucle while dans ce code.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include <stdio.h>
#include <string.h>
#define CAR 'e'
#define LGMAX 132
 
int main()
{
    /*programme déterminant le nombre de lettres "e" */
    char texte[LGMAX+1];
    char * adr;
    int ncar;
 
    printf("Tapez un texte termine par return.\n");
    gets(texte);
    ncar=0;
    adr=texte;
 
    while (adr=strchr(adr,CAR))
    {
        ncar++;
        adr++;
    }
 
    printf("Votre texte comporte %d fois le caractere %c",ncar,CAR);
 
}

Merci beaucoup.

[imperio]

Alors la fonction strchr renvoit un pointeur sur la prochaine position du caractere passe en parametre. Cependant j'ai l'impression qu'il manque des parentheses, j'aurais pense que la condition aurait plutot du avoir cette tete :

Code :

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

while ((adr=strchr(adr,CAR)))

Apres je me trompe peut-etre... Donc la boucle continue tant qu'un pointeur non-NULL est retourne (c'est a dire tant que le caractere 'e' dans le cas present est trouve) et incremente de un la variable ncar pour compter le nombre d'occurence. Il incremente aussi le pointeur d'une case a chaque tour pour que strchr ne renvoie pas a chaque fois la meme position dans la chaine.

[Sve@r]

Bonjour

Cependant j'ai l'impression qu'il manque des parentheses, j'aurais pense que la condition aurait plutot du avoir cette tete :

Code :

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

while ((adr=strchr(adr,CAR)))

Ben tu vois bien que ces parenthèses sont inutiles. C'est uniquement si tu devais ensuite comparer "adr" avec autre chose style while ((adr=strchr(adr,CAR)) == xxx)...

Il incremente aussi le pointeur d'une case a chaque tour pour que strchr ne renvoie pas a chaque fois la meme position dans la chaine.

Presque. En fait, adr prend la position du premier caractère trouvé. Donc si ce caractère se trouve en position 50, adr passe alors immédiatement à cette adresse et jumpe ainsi 49 itérations inutiles.
Ensuite, effectivement, adr se décale d'un cran et passe à la position suivante pour pouvoir rechercher de nouveau le caractère dans le reste de la chaine....

[Médinoc]

Sur un bon compilateur, les parenthèses évitent un warning, car elles sont interprétées comme "oui, je sais, une affectation dans une expression conditionnelle, mais je sais ce que je fais, c'est normal". Mais je trouve qu'il est quand même plus lisible de rajouter explicitement !=NULL à la fin de l'expression.

[imperio]

Bonjour

Ben tu vois bien que ces parenthèses sont inutiles. C'est uniquement si tu devais ensuite comparer "adr" avec autre chose style while ((adr=strchr(adr,CAR)) == xxx)...

Quand je compilais ce code sans parenthèse, j'avais un warning donc je pense qu'elles sont utiles.

Presque. En fait, adr prend la position du premier caractère trouvé. Donc si ce caractère se trouve en position 50, adr passe alors immédiatement à cette adresse et jumpe ainsi 49 itérations inutiles.
Ensuite, effectivement, adr se décale d'un cran et passe à la position suivante pour pouvoir rechercher de nouveau le caractère dans le reste de la chaine....

En quoi ce que j'ai écrit est-il différent de ce que toi tu as écrit ? C'est plus court mais j'ai bien l'impression que c'est la même chose...

Sur un bon compilateur, les parenthèses évitent un warning, car elles sont interprétées comme "oui, je sais, une affectation dans une expression conditionnelle, mais je sais ce que je fais, c'est normal". Mais je trouve qu'il est quand même plus lisible de rajouter explicitement !=NULL à la fin de l'expression.

Je suis tout à fait d'accord avec toi concernant le "!=NULL". Un peu de lisibilité ne tue pas et fait gagner un temps fou quand on relit un code plutôt long.

[foetus]

En quoi ce que j'ai écrit est-il différent de ce que toi tu as écrit ? C'est plus court mais j'ai bien l'impression que c'est la même chose...

Lorsque tu dis "Il incrémente aussi le pointeur d'une case a chaque tour pour que strchr ne renvoie pas a chaque fois la meme position dans la chaine."

Sve@r ne pensait pas à adr++ mais à strchr(adr,CAR)

Je suis tout à fait d'accord avec toi concernant le "!=NULL". Un peu de lisibilité ne tue pas et fait gagner un temps fou quand on relit un code plutôt long.

:bof: Si c'est pour mettre un !=NULL qui va alourdir le test autant refaire la boucle.
Mais je connais la réaction de certains sur ce point

Code à l'arrache

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
    adr = strchr(adr, CAR);
 
    while (adr != NULL) {
        ncar++;
 
        adr++;
        adr = strchr(adr, CAR);
 
// or   adr = strchr(++adr, CAR);
    }
 
 
// or
 
    char c = adr[0];
 
    ncar = 0;
 
    for(int pos = 0; c != '\0'; pos++, c = adr[pos]) {
        if (c == CAR) { ncar++; }
    }

Édit: avec une boucle for (code si dessus). Mais il faut éventuellement une variable caractère en plus et on ne peut pas initialiser ncar à zéro dans la boucle (à moins que la variable pos existe déjà)

[-Eks-]

Les contributeurs à ce fil ont déjà répondu sur le code d'adrbessy, où il y a effectivement une affectation dans l'argument du while.

sans strchr, on peut faire :

Code :

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

1
2
3
    while (*adr)
        if (*adr++ == CAR)                                                                                                                  
            ncar++;

Ce qui (me) parait moins compliqué, tout en exploitant la compacité du C.

Eks

[schonai]

sans strchr, on peut faire :

Code :

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

1
2
3
    while (*adr)
        if (*adr++ == CAR)                                                                                                                  
            ncar++;

Ce qui (me) parait moins compliqué, tout en exploitant la compacité du C.

Code :

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

1
2
3
 
while (*adr)
     ncar += (*adr++ == CAR);

Encore plus compacte

[Sve@r]

En quoi ce que j'ai écrit est-il différent de ce que toi tu as écrit ? C'est plus court mais j'ai bien l'impression que c'est la même chose...

Lorsque tu dis "Il incrémente aussi le pointeur d'une case a chaque tour pour que strchr ne renvoie pas a chaque fois la meme position dans la chaine."
Sve@r ne pensait pas à adr++ mais à strchr(adr,CAR)

C'est ça. Quand tu dis "il incrémente le pointeur d'une case à chaque tour", on a l'impression que tu dis qu'à chaque tour le pointeur passe à la case suivant immédiatement celle qui était au tour précédent balayant ainsi la chaine caractère par caractère. Tu n'avais pas explicité le fait que strchr() ait changé cette adresse en jumpant ainsi plusieurs caractères d'un coup.

Je suis tout à fait d'accord avec toi concernant le "!=NULL". Un peu de lisibilité ne tue pas et fait gagner un temps fou quand on relit un code plutôt long.

Ne jamais oublier qu'un code est 100 fois plus lu qu'écrit...

sans strchr, on peut faire :

Code :

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

1
2
3
    while (*adr)
        if (*adr++ == CAR)                                                                                                                  
            ncar++;

Oui mais on entre dans un autre débat: il y a une fonction dédiée à ce travail, l'utiliser permet de centraliser les modifications éventuelles de ce travail, et inversement ne pas l'utiliser introduit une "verrue", un nouveau codage d'un travail déjà codé par ailleurs, et ce nouveau codage sera à l'écart des optimisations éventuelles apportées à strchr()...

...tout en exploitant la compacité du C.

Ca fait longtemps que compacité n'est plus gage d'efficacité...

Code :

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

1
2
while (*adr)
     ncar += (*adr++ == CAR);

Encore plus compacte

Oui mais tu fais l'hypothèse qu'une égalité réussie vaut 1 ce qui n'est pas garanti. En effet, rien ne lui interdit de valoir autre chose tant que ce n'est pas 0 (par exemple CAR). Donc dans ce cas...

Code :

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

1
2
while (*adr)
     ncar += (*adr++ == CAR ?1 :0);

[-Eks-]

Salut Sve@r,

Pour moi, un code court et aisément compréhensible est préférable à un code plus long ou à un code plus alambiqué ou difficile à comprendre.

Si la fonction de strchr était de compter le nombre d'occurrences d'un caractère donné dans une chaîne donnée, je serai d'accord avec toi en principe. Reprogrammer une fonction (souvent moins bien) que d'autres ont passé des années à implémenter et tester est une mauvaise idée. Mais je ne vois pas dans la bibliothèque standard de fonction "dédiée à ce travail" comme tu le dis, et qui apporterait les bénéfices dont tu parles.

Par ailleurs, il faut se méfier des principes absolus. Le fait qu'une fonction existe dans la bibliothèque standard ne signifie pas non plus qu'elle doive nécessairement être systématiquement utilisée aveuglément. Avec un tel raisonnement, on pourrait se dire qu'une boucle for dans laquelle on veut parcourir toute la longueur d'une chaîne devrait utiliser strlen dans le test, ce qui serait tout le contraire de l'effet optimal dont tu parles. La compréhension de ce qu'est une chaîne en C et de la façon dont fonctionne strlen pour calculer la longueur est nécessaire. Le fait de tester si le caractère courant est '\0' pour savoir que la fin est atteinte ne crée pas une "verrue", mais fait l'économie de l'usage répété d'une fonction non nécessaire, même si elle semble à première vue "dédiée à ce travail".


Eks

[Sve@r]

Pour moi, un code court et aisément compréhensible est préférable à un code plus long ou à un code plus alambiqué ou difficile à comprendre.

Utiliser strchr() au lieu de ta boucle ne me semble pas tellement alambiqué ou difficile à comprendre (sauf pour un débutant comme adrbessy mais ce n'est pas la faute du code, juste de son inexpérience ; mais fort heureusement l'inexpérience est de courte durée tandis que la connaissance reste à vie)...

Mais je ne vois pas dans la bibliothèque standard de fonction "dédiée à ce travail" comme tu le dis, et qui apporterait les bénéfices dont tu parles.

Mouais. Effectivement ici traiter la chaine caractère par caractère sera probablement plus efficace qu'appeler strchr() (qui lui-même traite la chaine caractères par caractères) pour se positionner n caractères plus loins. Au final autant d'itérations mais plusieurs appels à strchr() avec tout le mécanisme que ça engendre...

Avec un tel raisonnement, on pourrait se dire qu'une boucle for dans laquelle on veut parcourir toute la longueur d'une chaîne devrait utiliser strlen dans le test, ce qui serait tout le contraire de l'effet optimal dont tu parles.

Non, tu ne peux pas sincèrement croire à un tel argument !!! Tu me dis "il ne faut pas appeler strlen() parce que, dans le for, le test (donc son appel) est fait à chaque itération". Moi je te réponds "tu utilises strlen() mais tu mémorises son résultat dans une variable que tu fais évaluer par le for". Ou bien "tu appelles strlen() en début de for et tu parcours la chaine dans l'autre sens". Bref ce n'est pas parce que celui qui programme oublie les caractéristiques du for qu'il faut en blâmer la fonction strlen(). Surtout que si tu remplaces strlen() par une boucle perso (de la même façon que t'as remplacé strchr() par une boucle), utiliser cette boucle de remplacement à la place de strlen() (dans le test du for j'entends) produira les mêmes inconvénients !!!

La compréhension de ce qu'est une chaîne en C et de la façon dont fonctionne strlen pour calculer la longueur est nécessaire. Le fait de tester si le caractère courant est '\0' pour savoir que la fin est atteinte ne crée pas une "verrue", mais fait l'économie de l'usage répété d'une fonction non nécessaire, même si elle semble à première vue "dédiée à ce travail".

C'est vrai c'est vrai, réécrire le code d'une fonction minimaliste apporte aussi certains avantages dont tu as raison de parler. Pour des raisons pédagogiques tout d'abord (combien de profs ont fait réécrire strlen() ou strcpy() ?), ou alors parce que les risques de voir des standards (tellement anciens que ça en devient des tables de la loi) changer sont moins qu'infinitésimaux. Par exemple, dans l'absolu, la bonne façon de balayer une chaine devrait être celle ci: for (i=0, pt=chaine, lg=strlen(chaine); i < lg; i++, pt++) {traitement(*pt)}. Comme ça, si un jour le '\0' change, suffit de modifier strlen() et ça continuera de fonctionner. Mais combien (moi le premier) écrivent ceci: for (pt=chaine; *pt != '\0'; pt++) {traitement(*pt)} en se disant "ça m'étonnerait que le '\0' change un jour"...?
Cela a d'ailleurs amené parfois des fonctions à disparaitre tout en continuant d'exister (je veux parler de tous les isalpha() isalnum() etc. qui sont souvent des macros cachées donc du code pur au lieu de fonctions (cependant j'ai vainement essayé de créer une macro strchr()). Ceci dit, si remplacer une fonction par une macro de son code devient avantageux, je préfère que ce soit fait dans la lib standard et de mon coté continuer à appeler les fonctions.
Mais c'est ensuite au cas par cas qu'il faut choisir l'une ou l'autre option. Tant qu'on a bien en tête les avantages mais aussi les inconvénients (avec les probabilités associées) de l'un ou de l'autre choix on aura alors de grandes chances de ne pas se tromper.


PS: mon exemple raté de macro strchr(): #define strchr(s, c) {char *pt; for (pt=(s); *pt != (c) && *pt != '\0'; pt++); (*pt) ?(*pt) : 0}. Mais quand j'écris char *pt=strchr("Hello", 'l'); et que le préprocesseur me remplace ça en char *pt={char *pt; for (pt=("Hello"); *pt != ('l') && *pt != '\0'; pt++); (*pt) ?(*pt) : 0}; ben mon compilo il saigne

[-Eks-]

Tu me dis "il ne faut pas appeler strlen() parce que, dans le for, le test (donc son appel) est fait à chaque itération (..)"

Je dis que "le fait qu'une fonction existe dans la bibliothèque standard ne signifie pas non plus qu'elle doive nécessairement être systématiquement utilisée aveuglément" et je donne un exemple de mauvais usage d'une autre fonction. Les exemples que tu donnes sont des exemples éclairés d'utilisation de strlen(), qui n'est pas non plus à bannir (je n'ai jamais dit cela). Néanmoins, ils restent plus longs et "alambiqués" que juste tester la fin de chaîne, dans un cas où, par ailleurs, on n'aurait pas réellement besoin à l'avance de connaître la taille.

Surtout que si tu remplaces strlen() par une boucle perso (de la même façon que t'as remplacé strchr() par une boucle) (...)

Les 3 lignes que j'ai produites ne remplacent pas strchr() par une boucle, elles trouvent le nombre d'occurrences d'un caractère dans une chaîne, ce que ne fait pas strchr(), et ce sans utiliser strchr().

Je ne suis pas partisan de réécrire des fonctions existantes.

Santé !


Eks