Utiliser un bloc while pour ne rien faire est-il une mauvaise chose?

StackOverflow https://stackoverflow.com/questions/445700

  •  22-07-2019
  •  | 
  •  

Question

Je travaille actuellement sur les exercices du 'Langage de programmation C'. Voici l'une de mes solutions: 

int c;

while ((c=getchar()) != EOF) {

if (c == ' ') {

    while ((c = getchar()) == ' ')

    {}  // do nothing?

    putchar(' ');

}

putchar(c);

}

J'ai trouvé des solutions ici qui sont assez différentes des miennes et utiliser une variable supplémentaire pour garder une trace de ce qui se passe, alors que je viens d'utiliser une boucle while pour passer à travers tous les espaces. Ma solution semble un peu brouillon, car il me semble un peu rusé d’avoir une boucle while sans rien entre les accolades. Je me demandais s'il y avait de bonnes raisons de ne pas le faire? Merci pour tout conseil :-)

Était-ce utile?

La solution

Pas du tout - je pense que vous trouverez des boucles sans faille comme celles-ci dans K & amp; R, donc c'est à peu près aussi officiel que possible.

C’est une question de préférence personnelle, mais je préfère mes boucles à ne rien faire comme ceci: 

while(something());

D'autres préfèrent que le point-virgule soit placé sur une ligne distincte, ce qui renforce le fait qu'il s'agisse d'une boucle: 

while(something())
  ;

D'autres préfèrent utiliser les crochets sans rien à l'intérieur, comme vous l'avez fait: 

while(something())
{
}

Tout est valable - il vous suffit de choisir le style qui vous convient et de vous y tenir.

Autres conseils

Votre question "L'utilisation d'un bloc while pour ne rien faire est-elle une mauvaise chose?" peut également être répondu en termes de gaspillage des cycles de processeur. Dans ce cas, la réponse est "Non", car le processus se mettra en veille tant que l'utilisateur attend de saisir un caractère.

Le processus ne se réveillera qu’après la saisie d’un caractère. Ensuite, le test aura lieu et si le test réussit, c.-à-d. C == '', le processus s'endormira de nouveau jusqu'à ce que le caractère suivant soit entré. Cela se répète jusqu'à ce qu'un caractère sans espace soit entré.

Je pense que c'est parfaitement acceptable.

Je voudrais soit l'écrire: 

//skip all spaces
while ((c = getchar()) == ' ') {}

pour faire comprendre que cette ligne de code fait une chose.

Ou je l'écrirais comme ceci: 

while ((c = getchar()) == ' ') {
    //no processing required for spaces
}

afin qu'il corresponde au reste du format de votre code.

Personnellement, je ne suis pas fan de la 

while ((c = getchar()) == ' ');

format. Je pense qu'il est trop facile d'oublier le point-virgule.

Eh bien, si vous n'aimez vraiment pas les accolades vides, vous pourriez reformer cette boucle interne en 

while (c == ' ') {c = getchar();}

Cela coûte une comparaison supplémentaire cependant, donc une boucle "while while" serait mieux.

Je ne pense pas que la procédure soit, mais votre formatage est assez étrange. Il n'y a rien de mal avec: 

/* Eat spaces */
while ((c = getchar()) == ' ');

(c'est-à-dire, indiquez qu'il n'y a pas intentionnellement un corps)

Je préférerais: 

while ((c = getchar()) == ' ') /* Eat spaces */;

On m'a également signalé qu'il existait une procédure nommée DoNothing spécialement pour appeler dans des cas comme celui-ci. Cela montre très clairement que vous voulez vraiment ne rien faire.

Bien que les corps de boucle inexistants soient parfaitement acceptables, il convient de TRÈS de préciser que c'est intentionnel.

Un tandis que qui ne fait rien probablement est une mauvaise chose: 

while(!ready) {
   /* Wait for some other thread to set ready */
}

... est un moyen vraiment très coûteux d'attendre - il utilisera autant de ressources processeur que le système d'exploitation le lui donnera, tant que ready est faux et que le temps de traitement est volé. avec lequel l’autre thread pourrait faire un travail utile.

Toutefois, votre boucle n’est pas active: 

while ((c = getchar()) == ' ')
    {};  // skip

... car il appelle getchar () à chaque itération. Par conséquent, comme tout le monde est d’accord, ce que vous avez fait va bien.

J'ai utilisé un code comme celui-ci. Je ne pense pas qu'il y ait vraiment de raison de ne pas l'utiliser si la situation le justifie.

Je pense qu’il n’ya pas de problème. Vous pouvez l'utiliser, dans de nombreuses situations, je le préfère.

La voie canonique & # 8212; utilisé depuis des temps immémoriaux, jetez un coup d'œil, par exemple, au livre lyonnais & # 8212; est 

while(condition)       // Here's the whole thing
    ;                  // empty body.

En fait, en général, la convention "demi-couleur sur une ligne séparée" est utilisée pour une instruction null. Vous verrez, par exemple, voir occasionnellement 

if( condition-1)
     ;
else if (condition-2)
     stmt;
else {
     // do stuff here
}

C'est beaucoup plus rare, mais il apparaît soit lorsque la condition-1 est très compliquée, de sorte que vous ne voulez pas la nier et le risque de confusion, ou lorsque le code a été optimisé à la main. dans un pouce de sa vie, de sorte que vous voulez d'abord le cas le plus commun.

Le 

while(condition) ;

forme est à éviter servilement, parce que c'est une faute de frappe commune et ennuyeuse: vous devez préciser que vous l'avez fait exprès. Bretelles vides 

 while(condition){
 }

ou ses variantes constituent également un problème, soit parce qu’ils ne ressortent pas suffisamment, soit, pire, que d’autres types de fautes de frappe.

Eh bien, pas vraiment, cela dépend de votre architecture. 

if (dosomething()) { ; }

Ce qui précède va constamment pousser et sauter de votre pile locale, ce qui entraîne une surcharge de mémoire. De plus, vous viderez également les pipelines de vos processeurs en effectuant des opérations noop.

Une option alternative qui n'a pas encore été mentionnée: 

while(condition)
    (void)0;

Je ne préfère vraiment pas écrire mes boucles de cette façon , mais j'avais un conseiller technique le semestre dernier.

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top