Что более эффективно я ++ или ++ i?

Ответ 1

i ++:

• создать временную копию i
• increment i
• вернуть временную копию

++ i:

• increment i
• return i

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

edit: имейте в виду, что в С++ я могу быть тем объектом, который поддерживает префикс и postfix ++. Для сложных объектов временная стоимость копирования не является незначительной.

Ответ 2

Я бы посмотрел в другом месте для потенциала оптимизации.

Ответ 3

Здесь то, что SO думает о префиксе С++ и postfix incrementer

Ответ 4

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

int i; i = 1; cout < я ++;//Возвращает 1

int i; i = 1; cout < ++ я;//Возвращает 2

Когда значение не важно, большинство компиляторов переведут как ++ i, так и я ++ (скажем, в цикле for) в один и тот же код машины/VM.

Ответ 5

Это не важно в современном компиляторе.

int v = i++;  

совпадает с

int v = i;
i = i + 1;

Современный компилятор обнаружит, что v не используется, а код для вычисления v является чистым (без побочных эффектов). Затем он удалит v и код назначения и сгенерирует это

i = i + 1;

Ответ 6

Это имеет значение! Особенно, если вы на С++...

++i // the prefered way, unless..
auto j = i++ // this is what you need

Вы всегда должны использовать префиксную нотацию, чтобы избежать необходимых накладных расходов на копирование и с С++ это важно!

Ответ 7

Ну, на С++ я считаю, что они имеют разные виды использования, в зависимости от того, когда вы хотите обновить переменную. Эффективность не должна определяться, когда вы используете один над другим, но я бы предположил, что они будут иметь одинаковую эффективность в любом случае.

Ответ 8

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

Ответ 9

++ я не нужна временная переменная для хранения вещей. Думайте о них следующим образом:

++ я

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, если вы слишком беспокоитесь об этом...:)

Ответ 10

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

Ответ 11

++ я занимает менее 1 процессорную инструкцию, чем я ++ в сборке x86 без оптимизации

Ответ 12

Нет никакой разницы. Используйте конструкцию, которая имеет наибольший смысл.

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

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

Ответ 13

++i быстрее, потому что i++ должен хранить i, затем увеличивать его, а затем возвращать сохраненное значение i. ++i просто увеличивает i и возвращает его.

// ++i
i += 1;
return i;

// i++
temp = i;
i += 1;
return temp;

Ответ 14

Автономный "i ++"; или "++ i;" должен генерировать одинаково эффективный код. Разница возникает, если вы используете ее в выражении, где "побочный эффект" вступает в игру.

Тем не менее, было время, назад, когда "весь мир - Vax", и компиляторы сосали, что ++ я сказал, что он более эффективен, чем я ++, даже в "for (i = 0; я < N; ++ i)".

Ответ 15

В этом вопросе stackoverflow есть отличный ответ: Есть ли разница в производительности между я ++ и ++ я в C?

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

Ответ 16

Как правило, проще набирать я ++, следовательно, он более эффективен с точки зрения производительности.

Серьезно, однако, если я - это собственный тип данных (например, int, double и т.д.) - никакой разницы.

И это зависит от реализации, если это пользовательский тип, например

class Type
{
    Type& operator ++(){}
    const Type& operator ++(int i){}
};  

T i;

Ответ 17

Нет правильного или неправильного ответа

Как это зависит от

1), как это было реализовано complier

2), что Cpu система работает на

3) Если я байтовое или двойное слово

Ответ 18

Это зависит от контекста, например:

x = i++ 

В этом случае "x" будет равно "i" , и только после этого "i" будет увеличено на единицу.

x = ++i

В этом случае "i" будет увеличиваться на единицу, а затем новое значение "x" будет присвоено "x" .

В случае цикла 'for' существует небольшая очевидная разница, отличная от производительности (++ я быстрее).

Ответ 19

В общем, более эффективно использовать ++ i, чем я ++. Простая причина этого в том, что ++ я полностью совпадает с

i + = 1;

который для x86 является одной инструкцией (и, вероятно, большинством других широко используемых архитектур). i ++, однако, равно

tmp = i; я + = 1;

Это потому, что старое значение "i" соответствует я ++. И, очевидно, это требует больше работы, чем просто я + = 1;

Но, как указано выше, это практически не влияет на достаточно умный компилятор, так как он будет оптимизировать неиспользуемые операции. Для многих интерпретируемых языков (пример: PHP), вероятно, минимальное увеличение скорости для ++ i; Но это увеличение незначительно.

Ответ 20

Как правило, в С++ постфикс потребует дополнительной конструкции объекта приращения, тогда как префикс применяется непосредственно к объекту. (Или так я читал)

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

Ответ 21

Трудно ответить на это, поскольку это зависит от реализации компилятора/интерпретатора.

Но, вообще говоря, вы можете примерно грубо расширить я ++ до следующих инструкций:

COPY i to tmp
INCREMENT tmp
SAVE tmp as i

В то время как ++ я будет примерно соответствовать:

LOAD i
INCREMENT i

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

Если вы пытаетесь выполнить такую ​​микро-оптимизацию, я бы посоветовал вам профилировать/измерить, прежде чем выбирать один за другим.