Точный дубликат: Есть ли разница в производительности между я ++ и ++ я на С++?
Точный дубликат: Разница между я ++ и ++ я в цикле?
Чем эффективнее я ++ или ++ i?
Я использовал это только в Java и C/С++, но я действительно прошу все языки, на которых это реализовано.
В колледже у меня был профессор, показывающий нам, что ++ я был более эффективным, но прошло уже пару лет, и я хотел бы получить информацию от сообщества SO.
i ++:
++ i:
При использовании оптимизаций вполне возможно, что результирующая сборка идентична, однако ++ я более эффективен.
edit: имейте в виду, что в С++ я могу быть тем объектом, который поддерживает префикс и postfix ++. Для сложных объектов временная стоимость копирования не является незначительной.
Я бы посмотрел в другом месте для потенциала оптимизации.
Здесь то, что SO думает о префиксе С++ и postfix incrementer
Эффективность не должна быть вашей проблемой: это значение. Эти два варианта не совпадают, если они не являются автономными: один использует предварительное использование значения, другое сообщение.
int i; i = 1; cout < я ++;//Возвращает 1
int i; i = 1; cout < ++ я;//Возвращает 2
Когда значение не важно, большинство компиляторов переведут как ++ i, так и я ++ (скажем, в цикле for) в один и тот же код машины/VM.
Это не важно в современном компиляторе.
int v = i++;
совпадает с
int v = i;
i = i + 1;
Современный компилятор обнаружит, что v не используется, а код для вычисления v является чистым (без побочных эффектов). Затем он удалит v и код назначения и сгенерирует это
i = i + 1;
Это имеет значение! Особенно, если вы на С++...
++i // the prefered way, unless..
auto j = i++ // this is what you need
Вы всегда должны использовать префиксную нотацию, чтобы избежать необходимых накладных расходов на копирование и с С++ это важно!
Ну, на С++ я считаю, что они имеют разные виды использования, в зависимости от того, когда вы хотите обновить переменную. Эффективность не должна определяться, когда вы используете один над другим, но я бы предположил, что они будут иметь одинаковую эффективность в любом случае.
++ я потенциально более эффективен для нетривиальной реализации оператора ++, но даже в этом сценарии компилятор может оптимизировать промежуточный временный.
++ я не нужна временная переменная для хранения вещей. Думайте о них следующим образом:
++ я
int preIncrement(int i)
{
i = i + 1;
return i;
}
++
int i = 5; // as an example
int postIncrement(_i)
{
int temp = _i;
i = _i + 1;
return temp;
}
См? Постинъект требует временную переменную. Предполагая, что компилятор не сортирует все это для вас, что почти наверняка делает.
Конечно, более важна программная логика; вы рискуете столкнуться с The Sad Tragedy of the Micro-Optimization Theatre, если вы слишком беспокоитесь об этом...:)
Если мне что-то не хватает, они должны иметь такую же эффективность. Они должны привести к одной команде добавления. Это просто вопрос, где происходит инструкция добавления: в начале или в конце строки кода.
++ я занимает менее 1 процессорную инструкцию, чем я ++ в сборке x86 без оптимизации
Нет никакой разницы. Используйте конструкцию, которая имеет наибольший смысл.
Если ваше приложение работает медленно, я могу гарантировать, что он будет никогда не бывает из-за разницы в скорости в целых приращениях операция. Если это так, это серьезная ошибка в компиляторе. скорость проблемы в вашем приложении будут являться алгоритмической неэффективностью, ожидая ввода-вывода и т.д.
Не беспокойтесь о проблемах, которые у вас нет. преждевременный Оптимизация - это корень всего зла.
++i быстрее, потому что i++ должен хранить i, затем увеличивать его, а затем возвращать сохраненное значение i. ++i просто увеличивает i и возвращает его.
// ++i
i += 1;
return i;
// i++
temp = i;
i += 1;
return temp;
Автономный "i ++"; или "++ i;" должен генерировать одинаково эффективный код. Разница возникает, если вы используете ее в выражении, где "побочный эффект" вступает в игру.
Тем не менее, было время, назад, когда "весь мир - Vax", и компиляторы сосали, что ++ я сказал, что он более эффективен, чем я ++, даже в "for (i = 0; я < N; ++ i)".
В этом вопросе stackoverflow есть отличный ответ: Есть ли разница в производительности между я ++ и ++ я в C?
Я хотел бы добавить, что вы должны использовать то, что лучше подходит вашим потребностям. За исключением критических для приложений приложений, это не важно. С академической точки зрения, лучше написать код, который выражает то, что вам нужно, и, наконец, оптимизировать.
Как правило, проще набирать я ++, следовательно, он более эффективен с точки зрения производительности.
Серьезно, однако, если я - это собственный тип данных (например, int, double и т.д.) - никакой разницы.
И это зависит от реализации, если это пользовательский тип, например
class Type
{
Type& operator ++(){}
const Type& operator ++(int i){}
};
T i;
Нет правильного или неправильного ответа
Как это зависит от
1), как это было реализовано complier
2), что Cpu система работает на
3) Если я байтовое или двойное слово
Это зависит от контекста, например:
x = i++
В этом случае "x" будет равно "i" , и только после этого "i" будет увеличено на единицу.
x = ++i
В этом случае "i" будет увеличиваться на единицу, а затем новое значение "x" будет присвоено "x" .
В случае цикла 'for' существует небольшая очевидная разница, отличная от производительности (++ я быстрее).
В общем, более эффективно использовать ++ i, чем я ++. Простая причина этого в том, что ++ я полностью совпадает с
i + = 1;
который для x86 является одной инструкцией (и, вероятно, большинством других широко используемых архитектур). i ++, однако, равно
tmp = i; я + = 1;
Это потому, что старое значение "i" соответствует я ++. И, очевидно, это требует больше работы, чем просто я + = 1;
Но, как указано выше, это практически не влияет на достаточно умный компилятор, так как он будет оптимизировать неиспользуемые операции. Для многих интерпретируемых языков (пример: PHP), вероятно, минимальное увеличение скорости для ++ i; Но это увеличение незначительно.
Как правило, в С++ постфикс потребует дополнительной конструкции объекта приращения, тогда как префикс применяется непосредственно к объекту. (Или так я читал)
Поскольку я не могу засвидетельствовать, как компилятор справляется с этим из-за моих ограниченных знаний по этому вопросу, он может быть обработан, если вы сделаете его спорным.
Трудно ответить на это, поскольку это зависит от реализации компилятора/интерпретатора.
Но, вообще говоря, вы можете примерно грубо расширить я ++ до следующих инструкций:
COPY i to tmp
INCREMENT tmp
SAVE tmp as i
В то время как ++ я будет примерно соответствовать:
LOAD i
INCREMENT i
Вы не можете просто сказать, что ++ я быстрее, чем я ++, поскольку реализация языка довольно умна, и они могут оптимизировать эти инструкции, когда вы знаете, что вы не получите доступ к временному значению я ++. Обычно это происходит, например, в цикле for. Поэтому во многих случаях это одно и то же.
Если вы пытаетесь выполнить такую микро-оптимизацию, я бы посоветовал вам профилировать/измерить, прежде чем выбирать один за другим.