Какое условие является предпочтительным в цикле?

StackOverflow https://stackoverflow.com/questions/477468

  •  20-08-2019
  •  | 
  •  

Вопрос 

int n = 5;
for(int i = 0;i!=n;i++)//condition !=
{
//executing 5times
}

int n = 5;
for(int i = 0;i<n;i++)//condition <
{
//executing 5times

}

Какой из них предпочтительнее?

Это был пример из "Ускоренного C ++ :практическое программирование на примере / Эндрю Кениг, Барбара Э.Му". Просто хотел узнать, почему автор предпочитает первый

Это было полезно?

Решение

Второй.По двум причинам

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

  2. != зависит от точного условия.Если внутренняя часть цикла будет изменена во время обслуживания, и я случайно увеличу значение внутри цикла, то в итоге вы получите бесконечный цикл.Как правило, всегда лучше сделать ваше условие завершения как можно более широким - оно просто более надежное.

2 - это, конечно, причина, по которой 1.

Другие советы

Я бы сказал < поскольку он охватывает более широкий набор условий.Предположим, что n не было константой, а возвращалось из функции, которая в редких случаях возвращала значение -1.В этом случае у вас был бы гораздо более длинный цикл (до тех пор, пока int не обернется до значения -ve!) с != версией цикла.

Используя condition < это намного лучше, потому что это уменьшает вероятность превышения вашего контрольного значения и попадания в бесконечный цикл.

Как указано в вопросе, оба цикла эквивалентны.Однако в реальном коде, как правило, все немного сложнее, и в этом случае "я < состояние n", как правило, немного более безопасное.Если, например, i может увеличиться более чем на единицу, это может превысить n, и тогда версия "i != n" приведет к вечному циклу.

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

int n = 5;
int i = 0;
while (i != n) {
    int old_i = i;
    // the real stuff of the loop here
   ++i;
   assert(i == old_i + 1);
}

(Или, что еще лучше, используйте язык, который поддерживает synxtax для указания предварительных и последующих условий и инвариантов цикла изначально.)

Книга "Ловушки и подводные камни C" Эндрю Кенига (см. http://en.wikipedia.org/wiki/C_Traps_and_Pitfalls для начала), вероятно, вам интересно, если вам нравится размышлять над такого рода вопросами.

Обычно я делаю второй способ, используя <.Но подумываю об использовании !=, поскольку итераторы stl в c ++ работают именно так.

Второй.Это всегда завершится в какой-то момент (при условии, что вы не делаете ничего смешного, например, играете со значением счетчика внутри цикла).

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

<n является наиболее используемым (мое мнение)

Я бы предпочел использовать < , поскольку, просто взглянув на код, вы можете сказать, что это увеличивающийся цикл, это подтверждает тот факт, что вы используете i ++.

Если вы используете i++ и < и по какой-то причине (другой программист, опечатка, человеческая ошибка) ваш код изменяет приращение на i - вы бы сразу поняли, что цикл не вычисляется, как с != это будет работать в любом случае, делая его менее тривиальным для отладки.

Я не вижу, что это имеет значение, разве нет более важных вещей, о которых стоит беспокоиться?

Я всегда использую последнее, и это то, что я видел чаще всего.

Хотя кто - нибудь обязательно пристрелит меня из - за этого ....

"я < n" - это лучше.Потому что, если вы используете "i != n" и в каком-то случае ваше начальное значение i больше n, вы войдете в бесконечный цикл.

Я считаю, что это лучшая альтернатива, если вы оптимизируете для скорость:

int n = 5;
for(int i = n;i > 0;i--)
{
//executing 5times
}

Причина этого в том, что сравнение с 0 происходит быстрее.

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

Петля, до тех пор, пока я меньше чем n

Который, я думаю, легче прочесть большинству программистов, включая меня.Если вы не знаете тип переменной итератора, вам следует делать как можно меньше предположений о его возможностях.В operator< может быть недоступен для i:Если это любой итератор, отличный от итератора произвольного доступа, operator< не гарантируется, что он будет доступен.В этом случае я бы использовал operator!=.

Я бы не стал предпочитать вариант < просто потому, что вы могли бы случайно "перешагнуть" конечное значение.Я думаю, что этот аргумент ошибочен.Потому что, если вы случайно перешагнули, то это ошибка, и ее следует заметить как можно скорее (Быстрый отказ).

Лицензировано под: CC-BY-SA с атрибуция
Не связан с StackOverflow
scroll top