Nunca visto antes em C ++ para loop

Eu estava convertendo um algoritmo C ++ para c #. Me deparei com isso para loop:

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

Ele não fornece erro em C ++, mas em C # (não é possível converter int em bool). Eu realmente não consigo descobrir isso para loop, onde está a condição?

Alguém pode me explicar?

PS. Apenas para verificar, para adaptar um VETOR a uma LIST, b.back () corresponde a b [b.Count-1]?

A condição do forloop está no meio - entre os dois ponto e vírgula ;.

Em C ++, não há problema em colocar quase qualquer expressão como condição: qualquer coisa que avalie como zero significa false; meios diferentes de zero true.

No seu caso, a condição é u--: quando você converter para C #, basta adicionar != 0:

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

Muitas respostas precisas, mas acho que vale a pena escrever o equivalente while.

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

É equivalente a:

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

Você pode refatorar para o formato while () ao traduzir para C #. Na minha opinião, é mais claro, menos uma armadilha para novos programadores e igualmente eficiente.

Como outros já apontaram - mas para completar minha resposta - para que funcione em C #, você precisaria mudar while(u--)para while(u-- != 0).

... ou while(u-- >0)apenas no caso de você começar negativo. (OK, b.size()nunca será negativo - mas considere um caso geral em que talvez algo mais tenha sido inicializado em u).

Ou, para deixar ainda mais claro:

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

É melhor ser claro do que ser conciso.

A condição é u--;, porque está na segunda posição da instrução for .

Se o valor de u--;for diferente de 0, será interpretado como true(ou seja, convertido implicitamente no valor booleano true). Se, em vez disso, seu valor for 0, ele será convertido em false.

Este é um código muito ruim .

Atualização: discuti a redação dos loops "for" nesta postagem do blog . Suas recomendações podem ser resumidas nos seguintes parágrafos:

Um loop for é um construto prático, legível (quando você se acostumar) e conciso, mas você precisa usá-lo bem. Por causa de sua sintaxe incomum, usá-lo de maneira muito imaginativa não é uma boa idéia.

Todas as partes do loop for devem ser curtas e legíveis. Nomes de variáveis ​​devem ser escolhidos para facilitar o entendimento.

Este exemplo viola claramente essas recomendações.

Esse será o formato C # do seu loop.

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

Apenas substitua o equivalente por size () e back ().

O que ele faz é reverter a lista e armazenar em uma matriz. Mas em C #, temos diretamente uma função definida pelo sistema para isso. Então você não precisa escrever esse loop também.

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

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

é inicialização.

u--

é a condição.

v = p[v]

é a iteração

A condição é o resultado de u--, que é o valor de uantes de ser diminuído.

Em C e C ++, um int é convertível em booleano implicitamente fazendo uma != 0comparação (0 é false, tudo o resto é true).

b.back()é o último elemento em um contêiner, ou seja b[b.size() - 1], quando size() != 0.

Em C, tudo que não é zero está trueem contextos "booleanos", como a condição final do loop ou uma instrução condicional. Em C # você tem que fazer essa verificação explícita: u-- != 0.

Conforme declarado por outros, o fato de o C ++ ter implícito a conversão para booleano significa que o condicional é u--, o que será verdadeiro se o valor for diferente de zero.

Vale acrescentar que você tem uma falsa suposição ao perguntar "onde está o condicional". No C ++ e no C # (e em outras linguagens com sintaxe semelhante), você pode ter uma condicional vazia. Neste caso, sempre avaliada como verdadeira, então o circuito continua para sempre, ou até algumas outras saídas condicioná-lo (via return, breakou throw).

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

De fato, qualquer parte da instrução for pode ser deixada de fora, caso em que simplesmente não é executada.

Em geral, for(A; B; C){D}ou for(A; B; C)D;se torna:

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

Qualquer um ou mais de A, B, C ou D pode ser deixado de fora.

Como resultado disso, algum favor for(;;) para loops infinitos. Faço isso porque, embora while(true)seja mais popular, li isso como "até que a verdade acabe sendo verdadeira", o que soa um pouco apocalíptico em comparação com a minha leitura for(;;) como "para sempre".

É uma questão de gosto, mas como não sou a única pessoa no mundo a gostar for(;;), vale a pena saber o que isso significa.

todas as respostas estão corretas: -

O loop for pode ser usado de várias maneiras, como a seguir:

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;

No código acima, ue vsão inicializados com b.size()e b.back().

Toda vez que a condição é verificada, ela também executa a instrução de decremento, ou seja u--.

O forloop sairá quando use tornar 0.

O erro encontrado no próprio C # limpa a dúvida. O loop for procura um

FALSO

condição para terminar. E como sabemos,

(BOOL) FALSE = (int) 0

mas o C # não pode processar isso sozinho, diferentemente do C ++. Portanto, a condição que você está procurando é

você--

mas você deve fornecer explicitamente a condição em C # como

u--! = 0

ou

u--> 0

Mas ainda tente evitar esse tipo de prática de codificação. o

enquanto loop

indicado acima em resposta é uma das versões mais simplificadas do seu

for-loop.

Se você está acostumado a C / C ++, esse código não é tão difícil de ler, embora seja bastante conciso e não muito bom. Então, deixe-me explicar as partes que são mais Cism do que qualquer outra coisa. Primeiro, a sintaxe geral de um loop C for assim:

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

O código de inicialização é executado uma vez. Em seguida, a condição é testada antes de cada loop e, por fim, o incremento é chamado após cada loop. Então, no seu exemplo, você encontrará a condiçãou--

Por que u--funciona como uma condição em C e não em C #? Porque C converte implicitamente muitas coisas em bools e isso pode causar problemas. Para um número, qualquer coisa que não seja zero é verdadeira e zero é falso. Portanto, ele fará a contagem regressiva de b.size () - 1 a 0. Ter o efeito colateral na condição é um pouco chato e seria preferível colocá-lo na parte de incremento do loop for, embora muito C código faz isso. Se eu estivesse escrevendo, faria mais assim:

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

A razão para isso é, pelo menos para mim, é mais claro. Cada parte do loop for faz seu trabalho e nada mais. No código original, a condição estava modificando a variável. A parte do incremento estava fazendo algo que deveria estar no bloco de código etc.

O operador de vírgula também pode estar jogando você para um loop. Em C, algo parecido x=1,y=2com uma declaração no que diz respeito ao compilador e se encaixa no código de inicialização. Apenas avalia cada uma das partes e retorna o valor da última. Então, por exemplo:

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

imprimiria 2.