signification de while(1)

Version imprimable

SALUT A TOUS!
J'ai un bout de code en C dans lequel il y a la boucle while(1). Je ne sais pas ce que cela signifie. Pouvez m'aidez?

Code:

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
void __stdcall lir_fic_met( char chaine[80],short *verif )
{
FILE *buf=NULL;
long pos;
int ret, an, jour;
float tmin, tmax;
 
Annee_x = 25;
Annee = calloc( Annee_x, sizeof(ST_ANNEE) );
Nb_annee = 0;

if (!Annee) exit(-1);
 
buf = fopen( chaine, "rb");
if (!buf) exit( -1 );

if (!fscanf( buf, "%f\r\n", &Latitude)) exit(-1);
while( 1 )
     {
     pos = ftell( buf );
     ret = fscanf( buf, "%2d%3d,%4f,%4f\r\n", &an, &jour, &tmax, 
&tmin);
     if (ret < 4) break;
     if (jour!=1) exit( -1 );
     Annee[Nb_annee].annee = 1900 + an;
     if (an < 20) Annee[Nb_annee].annee += 100; /* Annee 2000 */
     Annee[Nb_annee].pos   = pos;
     Nb_annee++;
     if (Nb_annee >= Annee_x)
 {
 Annee_x += 25;
 Annee = realloc( Annee, Annee_x * sizeof(ST_ANNEE));
        if (!Annee) exit(-1);
 }
     if (an%4==0) fseek( buf, 365L * 17, SEEK_CUR);
     else         fseek( buf, 364L * 17, SEEK_CUR);
     }
fclose( buf );
*verif= Nb_annee;
}

19/05/2006, 14h24
zul

il s'agit d'une boucle infinie. ( infinie dans le sens que la condition d'arret est toujours vérifié ). On va pouvoir sortir de la boucle grâce au break.
19/05/2006, 14h32
hamster

c'est tout de même une écriture un peu "sale" qui peut provenir d'une mauvaise analyse de l'algorithme.
Mieux vaut gérer des variables booléennes pour savoir quand sortir de la boucle
c'est mon avis sur les boucles infinies
;)
19/05/2006, 15h08
damienlann

dans un while tu mets une condition.
si cette condition est vrai tu executes ce qui se trouve dans le while sinon tu passe.
0 est toujours faux. le reste est toujours vrai (donc 1 est vrai).
donc dans while(1) la condition est toujours vrai donc on rentre dans la boucle et on en sort jamais : d'ou boucle infinie
:koi:heu..c'est clair?
19/05/2006, 15h14
Trap D
Il y a quand même des codes où on trouve des boucles du style
Code:

1 2 3 4 do { ............. } while (0);
Je ne souviens plus la nécessité exacte, si tant est que l'ai jamais sue ...
19/05/2006, 15h19
Gruik
Encore plus court comme syntaxe, il y a :
Code:

1 2 for (;;) { }
Citation:
Envoyé par Trap D

Il y a quand même des codes où on trouve des boucles du style

Code:

1 2 3 4 do { ............. } while (0);

Je ne souviens plus la nécessité exacte, si tant est que l'ai jamais sue ...
Copié collé de ce que j'ai écrit ailleurs :

Citation:

Envoyé par moi meme

Il est courant de vouloir créer des macros de 2 ou plusieurs instructions et sachant que le compilateur fait un bête remplacement de texte, on pourrait mettre autant d'instructions qu'on veut

#define MACRO(x) \
func(x);\
func2(x);

(Note : le "\" sert à continuer la macro sur la ligne suivante)

Seulement, dans l'utilisation d'un if, la macro ne serait pas interprétée comme une seule instruction
if (condition)
MACRO(x);
else
action();

Le else n'aurait donc plus de sens.

Pour eviter cela, on pourrait se dire qu'il suffit de creer un bloc, dans la macro :
#define MACRO(x) {\
func(x);\
func2(x); }

Mais non, car si on veut utiliser MACRO() comme un semblant de fonction, on devrait pouvoir mettre un ; à la fin.

Ainsi :
if (condition)
MACRO(x);
else
action();

serait traduit par

if (condition) {\
func(x);\
func2(x); }; /* <- point virgule ici */
else
action();
Le point virgule apres le bloc constituerait une instruction vide et il yaurait donc 2 instructions en tout dans le if. Le else serait donc en erreur.

Il fallait donc trouver un moyen pour qu'on puisse ecrire un bloc d'instruction tout en mettant le ;
La solution c'est la strucutre do while() qui oblige a mettre un point virgule apres le while()
En mettant comme condition à while une valeur toujours fausse, il n'yaurait pas de boucle. Le compilateur ignorerait meme la boucle (pas de perte de performance).

#define MACRO(x) do {\
func(x);\
func2(x); } while(0)
On ne met pas le point virgule apres le while(), c'est dans l'appel à la macro qu'on le mettra
MACRO(x);
19/05/2006, 15h23
Trap D

OK et merci, je crois que je l'ai vu ailleurs, mais je me trompes peut-être.
19/05/2006, 15h25
Gruik

C'est Emdel qui avait donné la super technique
19/05/2006, 18h09
Emmanuel Delahaye

Citation:

Envoyé par zul

il s'agit d'une boucle infinie. ( infinie dans le sens que la condition d'arret est toujours vérifié ).

jamais vérifiée...
19/05/2006, 18h13
Emmanuel Delahaye
Citation:
Envoyé par Trap D

Il y a quand même des codes où on trouve des boucles du style

Code:

1 2 3 4 do { ............. } while (0);

Je ne souviens plus la nécessité exacte, si tant est que l'ai jamais sue ...
Ou plutôt
Code:

1 2 3 4 do { ............. } while (0)
Ce n'est pas une boucle. On l'utilise (sans le ';') dans une macro quand on a besoin d'un bloc (plusieurs fonctions, variable locale, ...). L'absence de ';' oblige l'utilisateur à le fournir lors de l'appel, ce qui rend le code cohérent.
19/05/2006, 19h03
kantelise

merci
21/05/2006, 21h58
Médinoc

Le problème, c'est que certains compilos (visual...) mettent un warning quand ils voient une condition constante.

Le warning peut être contourné dans le cas du while(1) en le remplaçant par un for(;;), mais pas dans le cas du do-while(0)...