Инструкция: в то время как по сравнению с для

// I am also a fan of typedefs
for (const_iterator it = myVector.begin(), end = myVector.end();
     it != end && isValid(*it);
     ++it)
{ /* do stuff */ }

Мне кажется, что приведенный выше код менее читабелен, чем код ниже.

// I am also a fan of typedefs
const_iterator it = myVector.begin();
end = myVector.end();
while(it != end && isValid(*it))
{
    /* do stuff */ 
    ++it}

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

Я бы не стал так быстро отбрасывать циклы do-while. Они полезны, если вы знаете, что тело вашего цикла будет выполнено хотя бы один раз. Рассмотрим код, который создает один поток на каждое ядро ​​процессора. В случае цикла for это может появиться:

for (int i = 0; i < number_of_cores; ++i)
    start_thread(i);

При входе в цикл первое, что проверяется, - это условие, в случае если number_of_cores равно 0, и в этом случае тело цикла никогда не должно выполняться. Но погоди - это лишняя проверка! У пользователя всегда будет хотя бы одно ядро, иначе как работает текущий код? Компилятор не может исключить первое избыточное сравнение, насколько ему известно, number_of_cores может быть 0. Но программист знает лучше. Итак, исключив первое сравнение:

int i = 0;
do {
    start_thread(i++);
} while (i < number_of_cores);

Теперь каждый раз, когда выполняется этот цикл, выполняется только одно сравнение вместо двух на одноядерной машине (с циклом for условие истинно для i = 0, ложно для i = 1, тогда как do while ложно все время). Первое сравнение опущено, поэтому оно быстрее. С меньшим потенциалом ветвления меньше вероятность ошибочных прогнозов ветвления, поэтому это быстрее. Поскольку условие while теперь более предсказуемо (всегда ложно на 1-ядерном), предсказатель ветвления может работать лучше, а это быстрее.

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

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

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

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

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

В Ye Olde C циклы for и while не были одинаковыми.

Разница заключалась в том, что в циклах for компилятор мог свободно назначать переменную регистру ЦП и возвращать зарегистрироваться после цикла. Таким образом, подобный код имеет неопределенное поведение:

int i;
for (i = 0; i < N; i++) {
    if (f(i)) break;
}

printf("%d", i);           /* Non-defined behaviour, unexpected results ! */

Я не уверен на 100%, но я считаю, что это описано в K&R

Это нормально:

int i = 0;
while (i < N) {
    if (f(i)) break;
    i++;
}
printf("%d", i);

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