Ніколи не бачив 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

Багато точних відповідей, але я вважаю, що варто виписати еквівалентний цикл.

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).

Або, щоб зробити це ще зрозумілішим:

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

Краще бути зрозумілим, ніж бути лайливим.

Умова така u--; , тому що він знаходиться у другій позиції з за інструкції.

Якщо значення u--; відрізняється від 0, воно буде трактуватися як true(тобто неявно відведене до булевого значення true). Якщо натомість його значення дорівнює 0, воно буде враховано false.

Це дуже поганий код .

Оновлення. У цій публікації блогу я обговорював написання циклів "для" . Його рекомендації можна узагальнити у наступних параграфах:

Цикл для циклу - це практичний, читабельний (як тільки ви звикнете до нього) та лаконічна конструкція, але вам потрібно добре його використовувати. Через незвичайний синтаксис, використовувати його занадто образно, це не дуже гарна ідея.

Всі частини петлі 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;      
}

Просто замініть еквівалент за розміром () і назад ().

Що це робить, це повертає список і зберігає масив. Але в 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(;;), варто знати, що це означає.

всі відповіді правильні: -

петлю можна використовувати різними способами наступним чином:

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 # as

u--! = 0

або

u--> 0

Але все ж намагайтеся уникати подібної практики кодування. The

поки петля

сказане вище у відповіді - це одна з найбільш спрощених ваших версій

for-петля.

Якщо ви звикли до C / C ++, цей код не так важко читати, хоча він досить короткий і не дуже великий. Тож дозвольте мені пояснити частини, які є більшою за Cism ніж будь-що інше. Спочатку загальний синтаксис C для циклу виглядає так:

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 for виконує свою роботу і нічого іншого. У вихідному коді умова була зміною змінної. Зростаюча частина робила щось, що повинно бути в блоці коду тощо.

Оператор з комами може також кидати вас за цикл. У C щось на зразок x=1,y=2виглядає як одне твердження, що стосується компілятора, і вписується в код ініціалізації. Він просто оцінює кожну з частин і повертає значення останньої. Так, наприклад:

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

буде надруковано 2.