Je vois les différentes conventions utilisées dans de nombreux livres que j'avais lu, où vous créeriez des boucles infinies avec une structure de boucle telle que: mais vraiment, quelles sont les différences que je devrais savoir sur? Lequel est le meilleur?
6 Réponses :
Le premier ne sera pas compilé. Vous avez besoin d'au moins: tandis que (vrai) . Ils sont sémantiquement équivalents. C'est une question de style / choix personnel.
Il n'y a pas de différence.
Sauf dans la boucle tandis que vous devez mettre un certain état, par exemple. Voir aussi: Est "pour (;;)" plus rapide que "alors que (vrai)"? Sinon, pourquoi les gens l'utilisent-ils?
Aussi, le "meilleur" pourrait être celui qui n'est pas infini. :) tandis que (1) .
Bonne trouvaille avec l'autre question.
Ils sont sémantiquement l'équivalent. Une autre différence est que (x; y; z) {foo; } équivaut à x; tandis que (y) {foo; z; } . Ils ne sont pas exactement équivalents dans d'autres versions de la norme, dans l'exemple de pour (int x = 0; y; z) , la portée de x est le pour bloquer et est hors de portée après la fin de la boucle, alors que avec int x; tandis que (y) x il est toujours dans la portée après la fin de la boucle.
pour interprète manquant y comme vrai, tandis que pendant doit être fourni avec une expression. pour (;;) {foo; } va bien, mais tandis () {foo; } n'est pas.
FYI, question pose des questions sur les boucles infinies, pas la sémantique de VS en général.
Si vous souhaitez contourner la localité de la déclaration x , vous pourriez dire pour (x; y; z) {foo; } équivaut à {x; tandis que (y) {foo; z; }} .
En ce qui concerne la sémantique, la norme de langage C pour les boucles pour les boucles permet de construire une boucle à boucle identique à celle d'une boucle de temps. Cela confirme toutefois que la compréhension sémantique plus profonde d'une boucle de boucle, qui contient invariablement la variante de boucle (qui est souvent définie pour être identiquement positive pour des raisons de proximité). Pour une sémantique cohérente, une séparation claire entre les boucles où le nombre d'itérations est connu avant l'exécution de la boucle (pour les boucles) et des boucles où le nombre d'itérations n'est pas connu avant l'exécution (tandis que les boucles).
Votre réponse est inexacte. "(int x = 0; y; z), la portée de x est le blocage et est hors de portée après la fin de la boucle" vraie dans toutes les versions. "Int x; tandis que (y) x" (erreur de syntaxe) et aura lieu sur la localité du parent de toutes les versions. Donc, cette partie n'a pas assez frappé la marque.
Voici une petite différence que j'ai vue avec le démontage VS2010 en mode de débogage. Pas sûr, s'il suffit de compter comme une différence em> em> em> em> em> (sur tout le compilateur et avec toutes les optimisations). si conceptuellement ces boucles sont les mêmes , mais au niveau du processeur, avec des boucles de messages infinies, les cycles d'horloge pour les instructions supplémentaires / différentes pourraient être différents et faire une différence. P> while(1)
004113DE mov eax,1 **// This is the difference**
004113E3 test eax,eax **// This is the difference**
004113E5 je main+2Eh (4113EEh)
f();
004113E7 call f (4110DCh)
004113EC jmp main+1Eh (4113DEh) **// This is the difference**
for(;;)
f();
004113EE call f (4110DCh)
004113F3 jmp main+2Eh (4113EEh) **// This is the difference**
}
Cette différence n'existe définitivement avec aucune optimisation activée.
La différence est uniquement parce que le mode de débogage a des optimisations éteintes par défaut. Les 3 premières lignes vérifient en réalité si 1! = 0 , c'est-à-dire si la condition est vraie.
Et la différence de JMP est juste un décalage légèrement différent.
J'aime votre approche. C'est la réponse de type réel, mais je préfère ajouter plus de code d'assembleur avec des commentaires sur les lignes. Il y a beaucoup de choses en boucle. Le code DIS-ASM-ED pour (;;) ne le reflétera jamais, car votre compilateur optimise qui tue tout le but. (Par exemple, tandis que (0) {..} ne sera optimisé à rien).
Il n'y a pas de différence.
mais
tandis que () foo ();
n'est pas pareil que
pour (;; foo ();)
N'oubliez pas! Si vous cassez le moment avant la déclaration FOO (), FOO () n'exécute pas, mais si vous cassez le pour, FOO () s'exécute ...
Ils sont tous les deux les mêmes. Les compilateurs modernes émettent un code identique pour les deux .. intéressant (historiquement?) Le pour (;;) était plus populaire .. Les programmeurs Pascal ont fait un #define (;;) jamais et utilisée Forever {// code}