Условия выхода из цикла

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

Конечно, это также имеет немного ленивое преимущество того, чтобы быть тем меньше символа для ввода ;)

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

Я иногда предпочитаю это:

for (int i = 0; (i <= (n-1)); i++) { ... }

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

Другая версия:

for (int i = 1; (i <= n); i++) { ... }

помогает Вам определить, как часто тело цикла называют. Это также имеет допустимые варианты использования.

Используя любое из вышеупомянутого в c# вызвал бы ошибку компилятора, если бы Вы использовали меня вне цикла

Я предпочитаю использовать № 2, только потому, что я пытаюсь не расширить значение меня за пределами для цикла. Если бы я отслеживал переменную как этот, то я создал бы дополнительный тест. Некоторые могут сказать, что это избыточно или неэффективно, но это напоминает читателю моего намерения: На данном этапе я должен равняться N

@timyates - Я соглашаюсь, что не нужно полагаться на побочные эффекты

Я думаю, что Вы заявили очень хорошо различие между двумя. У меня действительно есть следующие комментарии, хотя:

• Это не "агностик языка", я вижу, что Ваши примеры находятся в C++, но существуют языки, где Нельзя изменить переменную цикла в цикле и других, которые не гарантируют, что значение индекса применимо после цикла (и некоторые делают обоих).

• Вы объявили i индекс в for таким образом, я не держал бы пари на значении i после цикла. Примеры являются немного вводящими в заблуждение как они, implictly принимают это for определенный цикл. В действительности это - просто более удобный способ записать:

  // version 1
  { int i = 0;
    while (i != N) {
      ...
      ++i;
    }
  }
  

  Отметьте как i не определено после блока.

Если бы программист знал, что все вышеупомянутое не сделало бы общее предположение о значении i и было бы достаточно мудро для выбора i<N как конечные условия, чтобы гарантировать, что условие выхода будут в конечном счете соблюдать.

Я думаю, что большинство программистов использует 2-й, потому что он помогает выяснить то, что продолжается в цикле. Я могу посмотреть на него и "знать", что запущу как 0 и определенно буду меньше, чем N.

1-й вариант не имеет этого качества. Я могу посмотреть на него, и все, что я знаю, то, что я запущу как 0 и что это никогда не будет равно N. Не совсем как полезный.

Независимо от того, как Вы завершаете цикл, всегда хорошо очень опасаться использовать контрольную переменную цикла вне цикла. В Ваших примерах Вы (правильно) объявляете меня в цикле, таким образом, это не находится в объеме вне цикла, и вопрос его значения спорен...

Конечно, 2-й вариант также имеет преимущество, что это - то, что все ссылки C я видел использование :-)

При доверии коду можно сделать также.

Если Вы хотите, чтобы Ваш код был читаем и понятен (и таким образом более терпимым для изменения от кого-то, которого необходимо принять, чтобы быть недотепой), я использовал бы что-то как;

for ( int i = 0 ; i >= 0 && i < N ; ++i) 

Я всегда использую № 2 как затем, можно быть уверены, что цикл завершится... Доверие ему являющийся равным N впоследствии полагается на побочный эффект... Вы только лучше использовали бы переменную N саму?

[редактирование] Извините... Я имел в виду № 2

В C++, с помощью != тест предпочтен для общности. Итераторы в C++ имеют различные понятия, как входной итератор, передают итератор, двунаправленный итератор, итератор произвольного доступа, каждый из которых расширяет предыдущий с помощью новых возможностей. Для < для работы итератор произвольного доступа требуется, тогда как != просто требует входного итератора.

Мы не должны смотреть на счетчик в изоляции - если бы по какой-либо причине кто-то изменил способ, которым увеличен счетчик, то они изменили бы условия завершения и получающуюся логику, если это требуется поскольку я == N.

Я предпочел бы второе условие, так как это более стандартно и не приведет к бесконечному циклу.

В целом я предпочел бы

for ( int i = 0; i < N; ++i )

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

Кроме того, в целом мне нравится избегать подобных циклов в пользу более читаемых циклов стиля foreach.

Для общей работы по программированию я предпочитаю

for ( int i = 0; i < N; ++i )

вместо

for ( int i = 0; i != N; ++i )

, потому что он менее подвержен ошибкам, особенно когда код подвергается рефакторингу. Я видел, как такой код случайно превратился в бесконечный цикл.

Я не верю, что этот аргумент «у вас возникнет искушение предположить, что i == N». Я никогда не делал этого предположения и не видел, чтобы другой программист делал это.