Никогда раньше не видел C ++ для цикла

Я конвертировал алгоритм C ++ в C #. Я наткнулся на это для цикла:

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

Это не дает ошибки в C ++, но в C # (не может преобразовать int в bool). Я действительно не могу понять это для цикла, где условие?

Может кто-нибудь объяснить, пожалуйста?

PS. Просто чтобы проверить, чтобы адаптировать ВЕКТОР к СПИСКУ, b.back () соответствует b [b.Count-1]?

Состояние forцикла находится посередине - между двумя точками с запятой ;.

В C ++ нормально помещать почти любое выражение в качестве условия: все, что оценивается как ноль, означает false; ненулевое означает true.

В вашем случае условие таково u--: когда вы конвертируете в C #, просто добавьте != 0:

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

Много точных ответов, но я думаю, что стоит написать эквивалентный цикл while.

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

Эквивалентно:

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

Вы можете рассмотреть возможность рефакторинга в формат while () при переводе на C #. На мой взгляд, это понятнее, меньше ловушек для новых программистов и одинаково эффективно.

Как уже отмечали другие, - но чтобы мой ответ был завершен - чтобы он работал в C #, вам нужно изменить while(u--)наwhile(u-- != 0) .

... или while(u-- >0)на тот случай, если у тебя отрицательный результат. (ХОРОШО,b.size() никогда не будет отрицательным - но рассмотрим общий случай, когда, возможно, что-то еще инициализировало вас).

Или, чтобы сделать это еще яснее:

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

Лучше быть ясным, чем кратким.

Условие u--;, потому что он находится во втором положении из за инструкции.

Если значение u--;отличается от 0, оно будет интерпретировано как true(то есть неявно приведено к логическому значению true). Если вместо этого его значение равно 0, оно будет приведено к false.

Это очень плохой код .

Обновление: я обсуждал написание цикла for в этом посте . Его рекомендации можно резюмировать в следующих параграфах:

Цикл for - это практичная, удобочитаемая (как только вы привыкнете к ней) и краткая конструкция, но вы должны хорошо ее использовать. Из-за его необычного синтаксиса, использование его слишком изобретательным способом не является хорошей идеей.

Все части цикла for должны быть короткими и удобочитаемыми. Имена переменных должны быть выбраны так, чтобы их было легко понять.

Этот пример явно нарушает эти рекомендации.

Это будет C # форма вашего цикла.

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

Просто замените эквивалент для size () и back ().

Что он делает, так это переворачивает список и сохраняет в массиве. Но в C # у нас напрямую есть определенная системой функция для этого. Таким образом, вам не нужно писать этот цикл также.

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

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

это инициализация.

u--

это условие.

v = p[v]

это итерация

Условие является результатом u--, которое является значением uдо того, как оно было уменьшено.

В C и C ++ переменная может int быть преобразована в bool путем неявного != 0сравнения (0 - это falseвсе, что есть true).

b.back()последний элемент в контейнере b[b.size() - 1], когда size() != 0.

В C все ненулевое значение находится trueв «логических» контекстах, таких как условие завершения цикла или условный оператор. В C # вы должны сделать это проверить явным: u-- != 0.

Как утверждают другие, тот факт, что C ++ имеет неявное приведение к логическому u--значению, означает условное значение , которое будет истинным, если значение будет отличным от нуля.

Стоит добавить, что у вас ложное предположение, спрашивая «где условное». И в C ++, и в C # (и в других языках с аналогичным синтаксисом) вы можете иметь пустое условное выражение. В этом случае всегда истинно, поэтому цикл продолжается вечно, или до некоторых других условий выходов он (через return, breakили throw).

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

Действительно, любая часть оператора for может быть пропущена, в этом случае она просто не выполняется.

В общем, for(A; B; C){D}или for(A; B; C)D;становится:

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

Любой из A, B, C или D может быть пропущен.

В результате этого, некоторые пользу for(;;) для бесконечных циклов. Я делаю это потому, что хотя while(true)это более популярно, я читаю это как «пока истина не станет правдой», что звучит несколько апокалиптически по сравнению с моим чтением for(;;) как «навсегда».

Это дело вкуса, но так как я не единственный человек в мире, которому нравится for(;;), стоит знать, что это значит.

все ответы верны: -

Цикл for может использоваться различными способами:

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;

В приведенном выше коде, uиv инициализируются с b.size()и b.back().

Каждый раз , когда проверяется условие, оно выполняет декремент заявления тоже есть u--.

forЦикл будет выходить , когда uбудет 0.

Ошибка, возникшая в самом C #, устраняет сомнения. Цикл for ищет

ЛОЖНЫЙ

условие прекратить. И, как мы знаем,

(BOOL) FALSE = (int) 0

но C # не может обработать это самостоятельно в отличие от C ++. Итак, условие, которое вы ищете

u--

но вы должны явно дать условие в C # как

u--! = 0

или

u--> 0

Но все же старайтесь избегать такого рода практики кодирования.

в то время как цикл

Изложенное выше в ответе является одной из самых упрощенных версий вашего

для цикла.

Если вы привыкли к C / C ++, этот код не так сложен для чтения, хотя он довольно лаконичен и не так хорош для кода. Итак, позвольте мне объяснить части, которые больше Cism, чем что-либо еще. Прежде всего, общий синтаксис цикла C for выглядит следующим образом:

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

Код инициализации запускается один раз. Затем условие проверяется перед каждым циклом и, наконец, приращение вызывается после каждого цикла. Итак, в вашем примере вы найдете условиеu--

Почему u--работает как условие в C, а не C #? Потому что C неявно преобразует многие вещи слишком быстро, и это может вызвать проблемы. Для числа все, что ненулевое, является истинным, а ноль - ложным. Так что он будет отсчитывать от b.size () - 1 до 0. Наличие побочного эффекта в условии немного раздражает, и было бы предпочтительнее поместить его в инкрементную часть цикла for, хотя большая часть C Код делает это. Если бы я писал это, я бы сделал это примерно так:

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

Причина этого, по крайней мере для меня, яснее. Каждая часть цикла for выполняет свою работу и ничего больше. В исходном коде условие модифицировало переменную. Часть приращения делала то, что должно быть в блоке кода и т. Д.

Оператор запятой также может привести вас к циклу. В C что-то похожее x=1,y=2выглядит как одно утверждение в отношении компилятора и вписывается в код инициализации. Он просто оценивает каждую из частей и возвращает значение последней. Так, например:

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

распечатал бы 2.