Разница между пре-приращением и пост-инкрементом в цикле?

Pre-increment ++ i увеличивает значение i и pre-increment возвращает новое увеличенное language-agnostic значение.

int i = 3;
int preIncrementResult = ++i;
Assert( preIncrementResult == 4 );
Assert( i == 4 );

Постинкремент i ++ увеличивает значение for i и возвращает исходное значение language-independent без приращения.

int i = 3;
int postIncrementResult = i++;
Assert( postIncrementtResult == 3 );
Assert( i == 4 );

В C++ обычно for-loop предпочтительнее предварительное language-agnostic приращение, если вы можете post-increment использовать и то, и другое.

Это for-loop связано с тем, что при использовании for постинкремента может потребоваться, чтобы language-agnostic компилятор сгенерировал код, который post-increment создает дополнительную временную language-agnostic переменную. Это связано с language-agnostic тем, что как предыдущие, так language-independent и новые значения увеличиваемой for-loop переменной должны где-то language-independent храниться, потому что они language-agnostic могут понадобиться в другом pre-increment месте в оцениваемом выражении.

Итак, по language-independent крайней мере, в C++ может for быть разница в производительности, которая post-increment будет определять ваш выбор, какой for использовать.

В основном это language-agnostic проблема, только если увеличиваемая pre-increment переменная является определяемым language-independent пользователем типом с переопределенным for оператором ++. Для примитивных language-independent типов (int и т. Д.) Разницы pre-increment в производительности нет. Но for стоит придерживаться оператора language-independent предварительного приращения for в качестве ориентира, если for только оператор постинкремента language-agnostic не является тем, что требуется.

Есть language-agnostic еще обсуждение here.

В C++, если post-increment вы используете STL, вы можете language-independent использовать циклы for с for-loop итераторами. В основном они for-loop имеют переопределенные операторы for ++, поэтому рекомендуется for использовать предварительное post-increment приращение. Однако компиляторы for-loop все время становятся умнее, и for-loop более новые могут выполнять language-independent оптимизацию, что означает language-independent отсутствие разницы в производительности, особенно language-independent если увеличиваемый тип определен language-independent встроенным в файл заголовка language-independent (как это часто бывает в реализациях for-loop STL), чтобы компилятор мог pre-increment видеть, как метод реализован, и pre-increment тогда он может знать, какие for-loop оптимизации безопасны для language-independent выполнения. Даже в этом случае, вероятно, все for же стоит придерживаться предварительного for-loop приращения, потому что циклы language-independent выполняются много раз, а language-independent это означает, что небольшое language-independent снижение производительности language-independent может вскоре усилиться.


В language-agnostic других языках, таких как for-loop C#, где нельзя перегрузить pre-increment оператор ++, нет разницы language-agnostic в производительности. Используемые language-independent в цикле для продвижения переменной language-independent цикла, операторы приращения for-loop до и после приращения эквивалентны.

Исправление: допускается for-loop перегрузка ++ в C#. Кажется, однако, что for-loop по сравнению с C++ в C# вы for не можете независимо перегружать for-loop версии до и после. Итак, я post-increment бы предположил, что если language-agnostic результат вызова ++ в C# не language-independent присваивается переменной post-increment или не используется как часть language-independent сложного выражения, то компилятор language-independent уменьшит до и после версии language-independent ++ до кода, который работает post-increment эквивалентно.

for-loop

language-agnostic

post-increment

pre-increment

2022-10-19T08:53:32+00:00