For (;;) быстрее, чем while (TRUE)? Если нет, то почему люди его используют?

1. Это не быстрее.
2. Если вам действительно интересно, скомпилируйте вывод на ассемблере для вашей платформы и посмотрите.
3. Это не имеет значения. Это не имеет значения. Пишите свои бесконечные циклы, как хотите.

Я предпочитаю for(;;) по двум причинам.

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

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

В то время как с while(true), при чем тут правда? Меня не интересует цикл до тех пор, пока истина не станет ложью, что буквально говорит эта форма (цикл, пока истина - истина). Я просто хочу зациклить.

И нет абсолютно никакой разницы в производительности.

Лично я использую for (;;), потому что в нем нет чисел, это просто ключевое слово. Я предпочитаю while (true), while (1), while (42), while (!0) и т. Д. И т. Д.

Благодаря Деннису Ричи

• Я начал использовать for (;;), потому что именно так Деннис Ричи делает это в K&R, и, изучая новый язык, я всегда стараюсь подражать умным парням.

• Это идиоматический C / C ++. Возможно, в конечном итоге будет лучше привыкнуть к этому, если вы планируете много делать в пространстве C / C ++.

• Ваш #define не будет работать, поскольку объект #define'd должен выглядеть как идентификатор C.

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

Это точно не быстрее ни в одном нормальном компиляторе. Оба они будут объединены в безусловные прыжки. Версия for легче набирать (как сказал Нил) и будет понятна, если вы понимаете синтаксис цикла for.

Если вам интересно, вот что дает мне gcc 4.4.1 для x86. Оба используют инструкцию x86 JMP.

void while_infinite()
{
    while(1)
    {
    puts("while");
    }
}

void for_infinite()
{
    for(;;)
    {
    puts("for");
    }
}

компилируется в (частично):

.LC0:
.string "while"
.text
.globl while_infinite
    .type   while_infinite, @function
while_infinite:
    pushl   %ebp
    movl    %esp, %ebp
    subl    $24, %esp
.L2:
    movl    $.LC0, (%esp)
    call    puts
    jmp .L2
    .size   while_infinite, .-while_infinite
    .section    .rodata
.LC1:
    .string "for"
    .text
.globl for_infinite
    .type   for_infinite, @function
for_infinite:
    pushl   %ebp
    movl    %esp, %ebp
    subl    $24, %esp
.L5:
    movl    $.LC1, (%esp)
    call    puts
    jmp .L5
    .size   for_infinite, .-for_infinite

Я предпочитаю for (;;), потому что он наиболее согласован в разных языках типа C.

В C ++ while (true) это нормально, но в C вы зависите от заголовка для определения true, но TRUE также является часто используемым макросом. Если вы используете while (1), это правильно в C, C ++ и JavaScript, но не в Java или C #, которые требуют, чтобы условие цикла было логическим, например while (true) или while (1 == 1). В PHP ключевые слова нечувствительны к регистру, но язык предпочитает регистр TRUE.

Однако for (;;) всегда полностью корректен на всех этих языках.

Я лично предпочитаю идиому for (;;) (которая будет компилироваться в тот же код, что и while (TRUE).

Использование while (TRUE) может быть более читаемым в каком-то смысле, я решил использовать идиому for (;;), потому что она выделяется.

Конструкция бесконечного цикла должна быть легко замечена или вызвана в коде, и я лично считаю, что стиль for (;;) делает это немного лучше, чем while (TRUE) или while (1).

Кроме того, я напоминаю, что некоторые компиляторы выдают предупреждения, когда управляющее выражение цикла while является константой. Я не думаю, что это случается слишком часто, но мне достаточно одной возможности ложных предупреждений, чтобы я хотел этого избежать.

Я видел, как некоторые люди предпочитают это, потому что у них есть #define где-то вроде этого:

#define EVER ;;

Что позволяет им написать это:

for (EVER)
{
    /* blah */
}

Что насчет (если ваш язык поддерживает):

start:
/* BLAH */
goto start;

Нет никакой разницы в смысле генерируемого машинного кода.

Однако, просто чтобы противостоять тенденции, я бы сказал, что форма while (TRUE) гораздо более читабельна и интуитивно понятна, чем для (;;), и что читаемость и ясность являются гораздо более важными причинами для руководящих принципов кодирования, чем любые причины, которые я ' я слышал о подходе for (;;) (я предпочитаю основывать свои рекомендации по кодированию на твердых аргументах и ​​/ или доказательствах эффективности самостоятельно).

Не просто известный шаблон, а стандартная идиома в C (и C ++)

while(true)

генерирует предупреждение с помощью Visual Studio (условие постоянно). В большинстве мест, где я работал, производственные сборки компилируются с предупреждениями как об ошибках. Так

for(;;)

является предпочтительным.

Оба должны быть одинаковыми, если ваш код оптимизирован компилятором. Чтобы объяснить, что я имею в виду под оптимизацией, вот пример кода, написанного на MSVC 10:

int x = 0;

while(true) // for(;;)
{
    x +=1;

    printf("%d", x);
}

Если вы собираете его в режиме отладки (без какой-либо оптимизации (/ Od)), разборка показывает явную разницу. Внутри while есть дополнительные инструкции для условия true.

while(true)
00D313A5  mov         eax,1                //extra 
00D313AA  test        eax,eax              //extra
00D313AC  je          main+39h (0D313B9h)  //extra
    {
        x +=1;
00D313AE  mov         eax,dword ptr [x]  
00D313B1  add         eax,1  
00D313B4  mov         dword ptr [x],eax  
    printf("%d", x);
    ...
    }
00D313B7  jmp         main+25h (0D313A5h)  


for(;;)
    {
        x +=1;
00D213A5  mov         eax,dword ptr [x]  
00D213A8  add         eax,1  
00D213AB  mov         dword ptr [x],eax  
    printf("%d", x);
    ...
    }
00D213AE  jmp         main+25h (0D213A5h)  

Однако, если вы создаете свой код в режиме Release (со значением по умолчанию Максимальная скорость (/ O2)), вы получите одинаковый результат для обоих. Оба цикла сводятся к одной инструкции перехода.

for(;;)
    {
        x +=1;
01291010  inc         esi  

        printf("%d", x);
    ...
    }
0129101C  jmp         main+10h (1291010h)  

    while(true)
    {
        x +=1;
00311010  inc         esi  

        printf("%d", x);
    ...
    }
0031101C  jmp         main+10h (311010h)  

Что бы вы ни использовали, не имеет значения для приличного компилятора с включенной оптимизацией скорости.

Какой из способов быстрее - это вопрос личных предпочтений. Лично я наборщик текста и никогда не смотрю на клавиатуру во время программирования - я могу набрать все 104 клавиши на клавиатуре.

Я найду, если быстрее набрать «пока (ИСТИНА)».

Я мысленно сложил несколько измерений движения пальцев и просуммировал их. «for (;;)» имеет около 12 значений ширины клавиш для перемещений назад и четвертое (между клавишами «домой» и клавишами, а также между клавишами «домой» и клавишей SHIFT) «в то время как (TRUE)» имеет около 14 значений ширины клавиш для перемещений назад и четвертый.

Однако при вводе последнего я гораздо менее подвержен ошибкам. Я мысленно думаю словами за раз, поэтому я считаю, что быстрее набирать такие вещи, как «nIndex», чем акронимы, такие как «nIdx», потому что мне приходится на самом деле мысленно произносить буквы, а не произносить их в уме и позволять пальцам автоматически -печатайте слово (как езда на велосипеде)

(Мой тест TypingTest.com = 136 слов в минуту)

Все хорошие ответы - поведение должно быть точно таким же.

ОДНАКО - Просто предположим, что это имело значение. Предположим, на одну итерацию приходилось еще 3 инструкции.

Вам должно быть все равно?

ТОЛЬКО в том случае, если то, что вы делаете внутри цикла, почти ничего, что почти никогда не имеет места.

Я хочу сказать, что есть микрооптимизация и макрооптимизация. Микрооптимизация похожа на «стрижку, чтобы похудеть».

Я не могу представить, что достойный компилятор сгенерирует какой-либо другой код. Даже если бы это было так, не было бы никакого способа определить без тестирования конкретного компилятора, который был бы более эффективным.

Однако я предлагаю вам предпочесть for(;;) по следующим причинам:

• ряд компиляторов, которые я использовал, будут генерировать предупреждение о постоянном выражении для while (true) с соответствующими настройками уровня предупреждения.

• в вашем примере макрос TRUE может быть определен не так, как вы ожидаете

• существует множество возможных вариантов бесконечного цикла while, таких как while(1), while(true), while(1==1) и т. д .; поэтому for(;;), вероятно, приведет к большей согласованности.

for(;;Sleep(50))
{
    // Lots of code
}

Яснее, чем:

while(true)
{
    // Lots of code
    Sleep(50);
}

Не то чтобы это применимо, если вы не используете Sleep().

Цикл «навсегда» популярен во встроенных системах в качестве фонового цикла. Некоторые люди реализуют это как:

for (; ;)
{
 // Stuff done in background loop
}

А иногда реализуется как:

while (TRUE /* or use 1 */)
{
 // Stuff done in background loop
}

И еще одна реализация:

do
{
 // Stuff done in background loop
} while (1 /* or TRUE */);

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

Я предполагаю, что while (true) более читабельно, чем for (;;) - похоже, что программист что-то упускает в цикле for :)

Самая важная причина использования «for (;;)» - это боязнь использования «while (TRUE)» при исследовательском программировании. С помощью «for» легче контролировать количество повторений, а также проще преобразовать цикл «for» в бесконечный.

Например, если вы создаете рекурсивную функцию, вы можете ограничить количество вызовов функции перед преобразованием в бесконечный цикл.

    for(int i=0;i<1000;i++) recursiveFunction(oneParam);

Когда я уверен в своей функции, я конвертирую ее в бесконечный цикл:

    for(;;) recursiveFunction(oneParam);

Как отмечали другие, это не имеет никакого значения с технической точки зрения. Некоторые люди думают, что один из них более читабелен, чем другой, и придерживаются разных мнений относительно этого.

Для меня это просто придирки, потому что любой программист на C должен уметь мгновенно распознавать как while(1), так и for(;;) как бесконечные циклы.

Ваше определение не сработает. Однако вы МОЖЕТЕ (но не должны) это делать:

#define repeat for(;;)

int main(void)
{
    repeat {
        puts("Hello, World");
    }
}

Но на самом деле, НЕ делайте этого ...