J'ai vu et p> pourquoi est-il vide comme ça. Merci. P> p>
6 Réponses :
Cela signifie faire pour toujours p>
pour (condition initiale; incrément; condition finale); Vous pouvez omettre l'un de ces p>
voir http://fr.wikipedia.org/wiki/for_loop p>
Les trois expressions de contrôle, séparés par des points-virgules ici, viennent de de gauche à droite de l'initialiseur expression, l'expression de test de boucle, et l'expression de comptage. Le initialisateur est évalué exactement une fois à droite au début de la boucle. Le L'expression de test de boucle est évaluée à le début de chaque itération à travers la boucle et détermine quand la boucle devrait sortir. Finalement, le compter l'expression est évalué à la fin de chaque itération de la boucle - même Si Continuer est appelé - et est généralement responsable de la modification de la boucle variable. p>
Dans la plupart des langues qui fournissent cette type de boucle, chacun des trois Les expressions de la boucle de contrôle sont facultatives. Quand omis l'expression de test de boucle est pris pour toujours être vrai, alors que le Expressions d'initialisateur et de comptage sont traités comme no-ops lorsqu'ils sont omis. Les points-virgules de la syntaxe sont suffisant pour indiquer l'omission de une des expressions. p> blockQuote>
La raison pour laquelle cela fonctionne est parce que lorsque l'état du milieu dans un pour (;;) code> est une boucle infinie. C'est effectivement la même chose que
tandis que (vrai) code>. P>
pour code> boucle est vide, il est interprété comme toujours vrai. P>
pour (; * s! = '\ 0'; s ++) code> est utilisé pour lire les chaînes de caractères. Cette approche fonctionne car chaque chaîne C se termine par un caractère null (
\ 0 code>). P>
Les pièces blanches ne font essentiellement rien. Donc, est juste une boucle normale sans aucune expression d'initialisation. Cela repose sur le fait que pour (;;) code> crée une boucle infinie qui ne fait rien du tout et ne quitte jamais car il n'y a pas d'état dans la boucle. Votre deuxième exemple:
s code> a déjà une valeur initiale et juste des boucles jusqu'à atteindre la fin de la chaîne. P> p>
Le et tout ou partie de ces trois peuvent être omis (blanc gauche). Donc: P>
1 sup> La boucle sera toujours interrompue s'il ya une instruction code> break code> dans le corps de la boucle ou un appel à pour code> instruction fonctionne comme: p>
pour (initialisation; condition de test; mise à jour) code> p>
pour (;;) code> est une boucle infinie 1 sup> équivalent à
tandis que (vrai) code> car il n'y a pas de condition de test. En fait,
pour (int i = 0 ;; i ++) code> serait également une boucle infinie 1 sup>. P> l>
pour (; * s! = '\ 0'; s ++) code> est une boucle sans initialisation.
s code> pointera au début de (probablement) une chaîne et est incrémenté jusqu'à ce qu'il atteigne le caractère null
'\ 0' code> indiquant la fin de la chaîne. Cela signifie essentiellement une boucle à travers tous les caractères de la chaîne
S code> p> li>
ul>
Quitter () code>, etc. ... p>
\ 0 code> est le caractère
nul code>.
nul code> et
null code> est différent.
@Prason Certaines personnes (comme moi-même) l'appelent juste le Null Caractère
Il est "vide comme ça" parce que l'auteur du code l'a laissé vide. L'auteur ne voulait pas / besoin de faire quoi que ce soit dans la section correspondante de la déclaration pour code>, il a donc été laissé vide. P>
pour (;;) code> est une instruction qui itière indéfiniment (sauf si elle n'est interrompue du corps à cycle intérieur). p>
pour (; * s! = '\ 0'; s ++) code> est une instruction qui n'a pas besoin d'une section d'initialisation, car tout le nécessaire (comme la valeur initiale de
S code>) a déjà été initialisé avant que
pour code> instruction. P>
tandis que (1) code> et
tandis que (vrai) code> sont identiques que
pour (;;) p> p> P>