Jamais vu auparavant C ++ for loop

Je convertissais un algorithme C ++ en C #. Je suis tombé sur ceci pour la boucle:

for (u = b.size(), v = b.back(); u--; v = p[v]) 
b[u] = v;

Il ne donne aucune erreur en C ++, mais il le fait en C # (impossible de convertir un int en booléen). Je ne peux vraiment pas comprendre cela pour la boucle, où est la condition?

Quelqu'un peut-il expliquer?

PS. Juste pour vérifier, pour adapter un VECTEUR à une LISTE, b.back () correspond-il à b [b.Count-1]?

La condition de la forboucle est au milieu - entre les deux points-virgules ;.

En C ++, il est possible de mettre presque n'importe quelle expression comme condition: tout ce qui est évalué à zéro signifie false; non nul signifie true.

Dans votre cas, la condition est la suivante u--: lorsque vous convertissez en C #, ajoutez simplement != 0:

for (u = b.size(), v = b.back(); u-- != 0; v = p[v]) 
    b[u] = v; //                     ^^^^ HERE

Beaucoup de réponses précises, mais je pense qu'il vaut la peine d'écrire l'équivalent en boucle while.

for (u = b.size(), v = b.back(); u--; v = p[v]) 
   b[u] = v;

Est équivalent à:

u = b.size();
v = b.back();
while(u--) {
   b[u] = v;
   v = p[v];
}

Vous pouvez envisager de refactoriser au format while () lorsque vous traduisez en C #. À mon avis, c'est plus clair, moins un piège pour les nouveaux programmeurs et tout aussi efficace.

Comme d'autres l'ont souligné - mais pour que ma réponse soit complète - pour que cela fonctionne en C #, vous devrez changer while(u--)pour while(u-- != 0).

... ou while(u-- >0)juste au cas où vous commenceriez par négatif. (OK, b.size()ne sera jamais négatif - mais considérons un cas général où peut-être quelque chose d'autre a initialisé u).

Ou, pour le rendre encore plus clair:

u = b.size();
v = b.back();
while(u>0) {
   u--;
   b[u] = v;
   v = p[v];
}

Il vaut mieux être clair que concis.

La condition est u--;, car il est dans la deuxième position de l' instruction for .

Si la valeur de u--;est différente de 0, elle sera interprétée comme true(c'est-à-dire transtypée implicitement en valeur booléenne true). Si, à la place, sa valeur est 0, il sera converti en false.

C'est un très mauvais code .

Mise à jour: j'ai discuté de l'écriture de boucles «for» dans ce billet de blog . Ses recommandations peuvent être résumées dans les paragraphes suivants:

Une boucle for est une construction pratique, lisible (une fois que vous vous y êtes habitué) et laconique, mais vous devez bien l'utiliser. En raison de sa syntaxe peu commune, l'utiliser de manière trop imaginative n'est pas une bonne idée.

Toutes les parties de la boucle for doivent être courtes et lisibles. Les noms de variables doivent être choisis pour faciliter leur compréhension.

Cet exemple enfreint clairement ces recommandations.

Ce sera la forme C # de votre boucle.

// back fetches the last element of vector in c++.
for (u = b.size(), v = b.back(); (u--) != 0; v = p[v]) 
{      
  b[u] = v;      
}

Remplacez simplement l'équivalent pour size () et back ().

Ce qu'il fait, c'est inverser la liste et les stocker dans un tableau. Mais en C #, nous avons directement une fonction définie par le système pour cela. Vous n'avez donc pas besoin d'écrire cette boucle également.

b = b.Reverse().ToArray();

u = b.size(), v = b.back()

est l'initialisation.

u--

est la condition.

v = p[v]

est l'itération

La condition est le résultat de u--, qui est la valeur de uavant qu'elle ne soit décrémentée.

En C et C ++, an int est convertible en booléen en faisant implicitement une != 0comparaison (0 est false, tout le reste est true).

b.back()est le dernier élément d'un conteneur, c'est-à- b[b.size() - 1]dire quand size() != 0.

En C, tout ce qui n'est pas nul est truedans des contextes "booléens", tels que la condition de fin de boucle ou une instruction conditionnelle. En C # , vous devez faire ce contrôle explicite: u-- != 0.

Comme indiqué par d'autres, le fait que C ++ ait un cast implicite en booléen signifie que le conditionnel est u--, qui sera vrai si la valeur est différente de zéro.

Cela vaut la peine d'ajouter que vous avez une fausse hypothèse en demandant "où est le conditionnel". En C ++ et C # (et dans d'autres langages de syntaxe similaire), vous pouvez avoir un conditionnel vide. Dans ce cas , il est toujours vraie, de sorte que la boucle continue pour toujours, ou jusqu'à ce que d'autres sorties de l' état (via return, breakou throw).

for(int i = 0; ; ++i)
  doThisForever(i);

En effet, n'importe quelle partie de l'instruction for peut être omise, auquel cas elle n'est tout simplement pas exécutée.

En général, for(A; B; C){D}ou for(A; B; C)D;devient:

{A}
loopBack:
if(!(B))
  goto escapeLoop;
{D}
{C}
goto loopBack;
escapeLoop:

N'importe lequel ou plusieurs parmi A, B, C ou D peuvent être omis.

En conséquence, certains favorisent for(;;) les boucles infinies. Je le fais parce que pendant que while(true)c'est plus populaire, je lis cela comme "jusqu'à ce que la vérité finisse par être vraie", ce qui semble quelque peu apocalyptique comparé à ma lecture for(;;) comme "pour toujours".

C'est une question de goût, mais comme je ne suis pas la seule au monde à aimer, for(;;)il vaut la peine de savoir ce que cela signifie.

toutes les réponses sont correctes: -

La boucle for peut être utilisée de différentes manières, comme suit:

Single Statement inside For Loop
Multiple Statements inside For Loop
No Statement inside For Loop
Semicolon at the end of For Loop
Multiple Initialization Statement inside For
Missing Initialization in For Loop
Missing Increment/Decrement Statement
Infinite For Loop
Condition with no Conditional Operator.

for (u = b.size(), v = b.back(); u--; v = p[v]) 
   b[u] = v;

Dans le code ci-dessus, uet vsont initialisés avec b.size()et b.back().

Chaque fois que la condition est vérifiée, elle exécute également l'instruction de décrémentation, c'est-à-dire u--.

La forboucle se terminera quand udeviendra 0.

L'erreur rencontrée dans C # lui-même efface le doute. La boucle for recherche un

FAUX

condition pour terminer. Et comme nous le savons,

(BOOL) FALSE = (entier) 0

mais C # ne peut pas traiter cela seul contrairement à C ++. La condition que vous recherchez est donc

u--

mais vous devez explicitement donner la condition en C # comme

u--! = 0

ou

u--> 0

Mais essayez toujours d'éviter ce genre de pratique de codage. le

boucle while

indiqué ci-dessus en réponse est l'une des versions les plus simplifiées de votre

boucle for.

Si vous êtes habitué à C / C ++, ce code n'est pas si difficile à lire, bien qu'il soit assez laconique et pas si génial en code. Alors laissez-moi vous expliquer les parties qui sont plus Cism qu'autre chose. Tout d'abord, la syntaxe générale d'une boucle C for ressemble à ceci:

for (<initialization> ; <condition>; <increment>)
{
    <code...>
}

Le code d'initialisation est exécuté une fois. Ensuite, la condition est testée avant chaque boucle et enfin l'incrément est appelé après chaque boucle. Donc, dans votre exemple, vous trouverez que la condition estu--

Pourquoi fonctionne-t-il u--comme une condition en C et non en C #? Parce que C convertit implicitement beaucoup de choses trop booléennes et cela peut causer des problèmes. Pour un nombre, tout ce qui est différent de zéro est vrai et zéro est faux. Donc, il compte à rebours de b.size () - 1 à 0. Avoir l'effet secondaire dans la condition est un peu ennuyeux et il serait préférable de le mettre dans la partie incrémentielle de la boucle for, bien que beaucoup de C le code fait cela. Si je l'écrivais, je le ferais plus comme ceci:

for (u = b.size() - 1, v = b.back(); u>=0; --u) 
{
    b[u] = v;
    v = p[v]
}

La raison en est, du moins pour moi, c'est plus clair. Chaque partie de la boucle for fait son travail et rien d'autre. Dans le code d'origine, la condition modifiait la variable. La partie incrémentation faisait quelque chose qui devrait être dans le bloc de code, etc.

L'opérateur virgule peut également vous lancer pour une boucle. En C, quelque chose comme x=1,y=2ressemble à une instruction en ce qui concerne le compilateur et s'inscrit dans le code d'initialisation. Il évalue simplement chacune des parties et renvoie la valeur de la dernière. Donc par exemple:

std::cout << "(1,2)=" << (1,2) << std::endl;

imprimerait 2.