В C, в чем разница между использованием ++i
и i++
и который должен использоваться в блоке инкрементации цикла for
?
++i
увеличит значение i
, а затем вернет увеличенное значение.
i = 1;
j = ++i;
(i is 2, j is 2)
i++
увеличит значение i
, но вернет исходное значение, которое i
удерживает до того, как будет увеличено.
i = 1;
j = i++;
(i is 2, j is 1)
Для цикла for
либо работает. ++i
кажется более распространенным, возможно, потому что это то, что используется в K & R.
В любом случае следуйте рекомендациям "предпочитайте ++i
по i++
", и вы не ошибетесь.
Там пара комментариев относительно эффективности ++i
и i++
. В любом компиляторе не-студента-проекта разница производительности не будет. Вы можете проверить это, посмотрев сгенерированный код, который будет идентичным.
Вопрос эффективности интересен... здесь моя попытка ответить: есть ли разница в производительности между i++ и ++i в C?
Как отмечает Фрейнд, он отличается for объектом C++, поскольку operator++()
является функцией, и компилятор не может знать, чтобы оптимизировать создание временного объекта для хранения промежуточного значения.
for(int i=0; i<10; i++){ print i; }
не будет ли это отличаться от for(int i=0; i<10; ++i){ print i; }
Насколько я понимаю, некоторые языки будут давать разные результаты в зависимости от того, какой язык вы используете.
i++ известен как Post Increment, тогда как ++i называется Pre Increment.
i++
i++
- это приращение, потому что после завершения операции увеличивается значение i
на 1.
Давайте посмотрим следующий пример:
int i = 1, j;
j = i++;
Здесь значение j = 1
, но i = 2
. Здесь значение i
будет назначено на j
, затем i
будет увеличено.
++i
++i
является предварительным приращением, потому что он увеличивает значение i
на 1 до операции. Это означает, что j = i;
будет выполняться после i++
.
Давайте посмотрим следующий пример:
int i = 1, j;
j = ++i;
Здесь значение j = 2
, но i = 2
. Здесь значение i
будет присвоено j
после i
приращения i
. Аналогично ++i
будет выполняться до j=i;
.
Для вашего вопроса, который должен использоваться в блоке инкрементации цикла for ? ответ: вы можете использовать любой... не имеет значения. Он выполнит ваш for цикл таким же образом. раз.
for(i=0; i<5; i++)
printf("%d ",i);
А также
for(i=0; i<5; ++i)
printf("%d ",i);
Оба цикла будут производить одинаковый вывод. т.е. 0 1 2 3 4
.
Это имеет значение только там, где вы его используете.
for(i = 0; i<5;)
printf("%d ",++i);
В этом случае вывод будет 1 2 3 4 5
.
Пожалуйста, не беспокойтесь о "эффективности" (скорость, действительно), из которой быстрее. В наши дни у нас есть компиляторы, которые заботятся об этом. Используйте то, что имеет смысл использовать, на основе чего более четко показано ваше намерение.
++i
увеличивает значение, а затем возвращает его.
i++
возвращает значение, а затем увеличивает его.
Это тонкая разница.
Для цикла for используйте ++i
, так как он немного быстрее. i++
создаст дополнительную копию, которая просто будет выброшена.
i++: - В этом сценарии сначала присваивается значение, а затем происходит увеличение.
++i: - В этом сценарии сначала выполняется приращение, а затем назначается значение
Ниже представлена визуализация изображения, а также вот хорошее практическое видео (http://www.youtube.com/watch?v=lrtcfgbUXm4), которое демонстрирует то же самое.
Причина ++i
может быть немного быстрее, чем i++
заключается в том, что i++
может потребоваться локальная копия значения i до того, как она будет увеличена, а ++i
никогда не будет. В некоторых случаях некоторые компиляторы оптимизируют его, если это возможно... но это не всегда возможно, и не все компиляторы делают это.
Я стараюсь не слишком полагаться на оптимизацию компиляторов, поэтому I' d следует совету Ryan Fox: когда i может использовать оба варианта, i использует ++i
.
i
чем значения 1, когда вы пишете оператор 1;
,
Эффективный результат использования либо идентичен. Другими словами, цикл будет делать то же самое в обоих случаях.
С точки зрения эффективности, может быть наказание за выбор i++ по сравнению с ++i. С точки зрения спецификации языка использование оператора post-increment должно создать дополнительную копию значения, на котором действует оператор. Это может быть источником дополнительных операций.
Однако вы должны рассмотреть две основные проблемы с предыдущей логикой.
Современные компиляторы великолепны. Все хорошие компиляторы достаточно умны, чтобы понять, что он видит целочисленное приращение в цикле for, и оптимизирует оба метода к одному и тому же эффективному коду. Если использование пост-инкремента по сравнению с предварительным приращением фактически заставляет вашу программу работать медленнее, вы используете ужасный компилятор.
С точки зрения сложности времени выполнения, два метода (даже если копия фактически выполняется) эквивалентны. Количество команд, выполняемых внутри цикла, должно значительно превышать количество операций в операции увеличения. Следовательно, в любом цикле значительного размера штраф за метод инкремента будет значительно затенен выполнением тела цикла. Другими словами, вам гораздо лучше беспокоиться об оптимизации кода в цикле, а не приращении.
На мой взгляд, весь вопрос просто сводится к предпочтению стиля. Если вы считаете, что pre-increment является более читаемым, используйте его. Лично I предпочитает post-incrment, но это, вероятно, потому, что это было то, что I преподавалось до того, как I ничего не знал об оптимизации.
Это типичный пример преждевременной оптимизации, и подобные проблемы могут отвлечь нас от серьезных проблем в дизайне. Однако по-прежнему возникает хороший вопрос, потому что нет единообразия в использовании или консенсусе в "лучшей практике".
++i (операция префикса): увеличивает и затем присваивает значение
(например): int i = 5, int b = ++i< br> В этом случае 6 сначала назначается b, а затем увеличивается до 7 и так далее.
i++ (операция Postfix): назначает и затем увеличивает значение
(например): int i = 5, int b = i++< br> В этом случае 5 сначала назначается b, а затем увеличивается до 6 и так далее.
Включение цикла for : i++ в основном используется, потому что обычно мы используем начальное значение i до увеличения в for . Но в зависимости от вашей программной логики это может различаться.
Разницу можно понять с помощью этого простого кода C++ ниже:
int i, j, k, l;
i = 1; //initialize int i with 1
j = i+1; //add 1 with i and set that as the value of j. i is still 1
k = i++; //k gets the current value of i, after that i is incremented. So here i is 2, but k is 1
l = ++i; // i is incremented first and then returned. So the value of i is 3 and so does l.
cout << i << ' ' << j << ' ' << k << ' '<< l << endl;
return 0;
++i - предварительный приращение, другое - пост-приращение
i++: получает элемент, а затем увеличивает его.
++i: увеличивает i , а затем возвращает элемент
Пример:
int i = 0;
printf("i: %d\n", i);
printf("i++: %d\n", i++);
printf("++i: %d\n", ++i);
Вывод:
i: 0
i++: 0
++i: 2
Я предполагаю, что теперь вы понимаете разницу в семантике (хотя, честно говоря, I задаются вопросом, почему люди спрашивают "что означает оператор X означает" вопросы о переполнении стека ", а не читают, знаете ли, книгу или веб-учебник или что-то еще.
Но в любом случае, насколько можно использовать, игнорировать вопросы производительности, которые вряд ли важны даже в C++. Это принцип, который вы должны использовать при принятии решения о том, что использовать:
Скажите, что вы имеете в виду в коде.
Если вам не нужно значение-до-increment в вашем заявлении, не используйте эту форму оператора. Это второстепенная проблема, но если вы не работаете с руководством по стилю, которое запрещает одну версию в пользу другого вообще (так называемое руководство по стилю с костью), вы должны использовать форму, которая наиболее точно выражает то, что вы пытаетесь сделать.
QED, используйте предварительную инкрементную версию:
for (int i = 0; i != X; ++i) ...
Следующий фрагмент кода C иллюстрирует разницу между операторами pre и post increment and decment:
int i; int j;
//Принудительные операторы
я = 1;
j = ++i;// i теперь 2, j также 2
j = i++;// i теперь 3, j равно 2
Pre-crement означает приращение в той же строке. Пост-приращение означает приращение после выполнения строки.
int j=0;
System.out.println(j); //0
System.out.println(j++); //0. post-increment. It means after this line executes j increments.
int k=0;
System.out.println(k); //0
System.out.println(++k); //1. pre increment. It means it increments first and then the line executes
Когда дело доходит с операциями OR, AND, это становится более интересным.
int m=0;
if((m == 0 || m++ == 0) && (m++ == 1)) { //false
/* in OR condition if first line is already true then compiler doesn't check the rest. It is technique of compiler optimization */
System.out.println("post-increment "+m);
}
int n=0;
if((n == 0 || n++ == 0) && (++n == 1)) { //true
System.out.println("pre-increment "+n); //1
}
В массиве
System.out.println("In Array");
int[] a = { 55, 11, 15, 20, 25 } ;
int ii, jj, kk = 1, mm;
ii = ++a[1]; // ii = 12. a[1] = a[1] + 1
System.out.println(a[1]); //12
jj = a[1]++; //12
System.out.println(a[1]); //a[1] = 13
mm = a[1];//13
System.out.printf ( "\n%d %d %d\n", ii, jj, mm ) ; //12, 12, 13
for (int val: a) {
System.out.print(" " +val); //55, 13, 15, 20, 25
}
В C++ пост/предварительный приращение указательной переменной
#include <iostream>
using namespace std;
int main() {
int x=10;
int* p = &x;
std::cout<<"address = "<<p<<"\n"; //prints address of x
std::cout<<"address = "<<p<<"\n"; //prints (address of x) + sizeof(int)
std::cout<<"address = "<<&x<<"\n"; //prints address of x
std::cout<<"address = "<<++&x<<"\n"; //error. reference can't re-assign because it is fixed (immutable)
}
Главное отличие
++i Pre (до приращения)
В ближайшее время: ++i и i++ работают одинаково, если вы не записываете их в функцию. Если вы используете что-то вроде функции (i++) или функции (++i), вы можете увидеть разницу.
function [++i) говорит о первом приращении i на 1, после чего добавьте этот i в функцию с новым значением.
function [i++) говорит, что сначала добавьте i в функцию после этого приращения i на 1.
int i=4;
printf("%d\n",pow(++i,2));//it prints 25 and i is 5 now
i=4;
printf("%d",pow(i++,2));//it prints 16 i is 5 now
int j = ++i;
и int k = i++;
даже когда нет вызова функции.
a = i++ означает, что значение i будет сохранено в без приращения значения a = ++i i будет сохранено с увеличением...
a = i++;
означает, что значение, сохраненное в a
будет значением i
до приращения, но «без приращения» подразумевает, что i
не увеличивается, что совершенно неверно - i
увеличивается, но значением выражения является значение до приращения.
Вот пример, чтобы понять разницу
int i=10;
printf("%d %d",i++,++i);
output: 10 12/11 11
(в зависимости от порядка оценки аргументов функции printf
, которая зависит от компиляторов и архитектур)
Объяснение: i++
→ i
печатается, а затем увеличивается. (Отпечатки 10, но i
станет 11). ++i
→ i
значение увеличивает и печатает значение. (Отпечатки 12 и значение i
также 12)
i++
и ++i
нет точки последовательности