Условие цикла: почему "неравномерно" вместо "ниже, чем",

Мне было поручено работать над проектом Android-Java (в режиме реального времени) со значительной (частично устаревшей) базой кода.

Большинство петель, которые я вижу, похожи на это (где mjk обычно является массивом Java):

    int count = mjk.length;
    for (int i = 0; i != count; ++i) {
        // Stuff dealing with mjk[i]
    }

Я вообще пишу такие петли, как это:

    int count = mjk.length;
    for (int i = 0; i < count; i++) {
        // Stuff dealing with mjk[i]
    }

Любая идея, почему оригинальный автор (с которым я не мог связаться до сих пор) использовал предыдущую форму? Это распространено в С++?

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

Мне просто интересно, есть ли у первого использования какие-либо преимущества/недостатки по сравнению со вторым (во всех отношениях).

Ответы

Ответ 1

Вторая форма имеет одно явное преимущество: если вы за какую-то ошибку манипулируете i внутри цикла, первая форма, вероятно, сработает, если i получит присвоенное значение больше mjk.length, а вторая форма будет просто завершает цикл.

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

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

Ответ 2

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

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

Ответ 3

Я думаю, что человек, который написал код, может много любить Контейнеры (карты, вектор) (!!)

Потому что!= в основном используется для итерации через элементы контейнера. Например, для итерации через элементы любого общего типа!= Будет работать как для карт, так и для векторов, в то время как < будет работать только для вектора. Так что для итерации используются элементы общего времени! =. Вместо этого я не нахожу никаких других преимуществ. (надеется на экспертную оценку или исправление)

Ответ 4

Я помню, что встречал это довольно давно, когда кодировал С++.

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

Ответ 5

Если переменная цикла i каким-то образом получает неправильное значение вне диапазона внутри цикла, первая версия будет сбой, а вторая версия просто закончит цикл.

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

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