What is the difference between ++i and i++?
In C, what is the difference between using ++i and i++ , and which should be used in the incrementation block of a for loop?
20 Answers 20
++i will increment the value of i , and then return the incremented value.
i++ will increment the value of i , but return the original value that i held before being incremented.
For a for loop, either works. ++i seems more common, perhaps because that is what is used in K&R.
In any case, follow the guideline «prefer ++i over i++ » and you won’t go wrong.
There’s a couple of comments regarding the efficiency of ++i and i++ . In any non-student-project compiler, there will be no performance difference. You can verify this by looking at the generated code, which will be identical.
The efficiency question is interesting. here’s my attempt at an answer: Is there a performance difference between i++ and ++i in C?
As @OnFreund notes, it’s different for a C++ object, since operator++() is a function and the compiler can’t know to optimize away the creation of a temporary object to hold the intermediate value.
i++ is known as post increment whereas ++i is called pre increment.
i++
i++ is post increment because it increments i ‘s value by 1 after the operation is over.
Let’s see the following example:
Here value of j = 1 , but i = 2 . Here the value of i will be assigned to j first, and then i will be incremented.
++i
++i is pre increment because it increments i ‘s value by 1 before the operation. It means j = i; will execute after i++ .
Let’s see the following example:
Here the value of j = 2 but i = 2 . Here the value of i will be assigned to j after the i incremention of i . Similarly, ++i will be executed before j=i; .
For your question which should be used in the incrementation block of a for loop? the answer is, you can use any one. It doesn’t matter. It will execute your for loop same number of times.
Both the loops will produce the same output. I.e., 0 1 2 3 4 .
It only matters where you are using it.
In this case output will be 1 2 3 4 5 .
i++ : In this scenario first the value is assigned and then increment happens.
++i : In this scenario first the increment is done and then value is assigned
Below is the image visualization and also here is a nice practical video which demonstrates the same.
++i increments the value, then returns it.
i++ returns the value, and then increments it.
It’s a subtle difference.
For a for loop, use ++i , as it’s slightly faster. i++ will create an extra copy that just gets thrown away.
Please don’t worry about the «efficiency» (speed, really) of which one is faster. We have compilers these days that take care of these things. Use whichever one makes sense to use, based on which more clearly shows your intent.
The only difference is the order of operations between the increment of the variable and the value the operator returns.
This code and its output explains the the difference:
So basically ++i returns the value after it is incremented, while i++ return the value before it is incremented. At the end, in both cases the i will have its value incremented.
Many times there is no difference
Differences are clear when the returned value is assigned to another variable or when the increment is performed in concatenation with other operations where operations precedence is applied ( i++*2 is different from ++i*2 , as well as (i++)*2 and (++i)*2 ) in many cases they are interchangeable. A classical example is the for loop syntax:
has the same effect of
Efficiency
Pre-increment is always at least as efficient as post-increment: in fact post-increment usually involves keeping a copy of the previous value around and might add a little extra code.
As others have suggested, due to compiler optimisations many times they are equally efficient, probably a for loop lies within these cases.
Rule to remember
To not make any confusion between the two operators I adopted this rule:
Associate the position of the operator ++ with respect to the variable i to the order of the ++ operation with respect to the assignment
Said in other words:
- ++ before i means incrementation must be carried out beforeassignment;
- ++ after i means incrementation must be carried out afterassignment:
The reason ++i can be slightly faster than i++ is that i++ can require a local copy of the value of i before it gets incremented, while ++i never does. In some cases, some compilers will optimize it away if possible. but it’s not always possible, and not all compilers do this.
I try not to rely too much on compilers optimizations, so I’d follow Ryan Fox’s advice: when I can use both, I use ++i .
The effective result of using either in a loop is identical. In other words, the loop will do the same exact thing in both instances.
In terms of efficiency, there could be a penalty involved with choosing i++ over ++i. In terms of the language spec, using the post-increment operator should create an extra copy of the value on which the operator is acting. This could be a source of extra operations.
However, you should consider two main problems with the preceding logic.
Modern compilers are great. All good compilers are smart enough to realize that it is seeing an integer increment in a for-loop, and it will optimize both methods to the same efficient code. If using post-increment over pre-increment actually causes your program to have a slower running time, then you are using a terrible compiler.
In terms of operational time-complexity, the two methods (even if a copy is actually being performed) are equivalent. The number of instructions being performed inside of the loop should dominate the number of operations in the increment operation significantly. Therefore, in any loop of significant size, the penalty of the increment method will be massively overshadowed by the execution of the loop body. In other words, you are much better off worrying about optimizing the code in the loop rather than the increment.
In my opinion, the whole issue simply boils down to a style preference. If you think pre-increment is more readable, then use it. Personally, I prefer the post-incrment, but that is probably because it was what I was taught before I knew anything about optimization.
This is a quintessential example of premature optimization, and issues like this have the potential to distract us from serious issues in design. It is still a good question to ask, however, because there is no uniformity in usage or consensus in «best practice.»
В чем разница между ++i и i++?
В C, в чем разница между использованием ++i и i++ , и что следует использовать в блоке инкрементации цикла for ?
Сведения об ответе
06:35, 21st August, 2020
++i увеличит значение i , а затем вернет увеличенное значение.
i++ увеличит значение i , но вернет исходное значение, которое i удерживалось до увеличения.
Для цикла for работает либо то, либо другое. ++i кажется более распространенным, возможно, потому, что именно это используется в K&R .
В любом случае, следуйте рекомендациям «предпочитайте ++i вместо i++ «, и вы не ошибетесь.
Есть несколько замечаний относительно эффективности ++i и i++ . В любом компиляторе non-student-project разницы в производительности не будет. Вы можете проверить это, посмотрев на сгенерированный код, который будет идентичен.
Интересен вопрос эффективности. вот моя попытка ответить на этот вопрос: Есть ли разница в производительности между i++ и ++i в C?
Как и в Заметках Фрейнда , для объекта C++ все по-другому, поскольку operator++() -это функция, и компилятор не может знать, как оптимизировать создание временного объекта для хранения промежуточного значения.
Сведения об ответе
06:52, 2nd August, 2020
i++ известен как Post Increment , тогда как ++i называется Pre Increment.
i++
i++ -это post increment, поскольку он увеличивает значение i на 1 после завершения операции.
Давайте рассмотрим следующий пример:
Здесь значение j = 1 , но i = 2 . Здесь значение i будет присвоено сначала j , а затем i будет увеличено.
++i
++i -это предварительное приращение, поскольку оно увеличивает значение i на 1 Перед операцией. Это означает, что j = i; будет выполняться после i++ .
Давайте рассмотрим следующий пример:
Здесь значение j = 2 но i = 2 . Здесь значение i будет присвоено j после приращения i к i . Точно так же ++i будет выполняться перед j=i; .
Для вашего вопроса, который должен использоваться в блоке инкрементации цикла for? ответ заключается в том, что вы можете использовать любой из них.. но это не имеет значения. Он будет выполнять ваш цикл for же нет. раз.
Оба цикла будут производить одинаковый выход. то есть 0 1 2 3 4 .
Важно только, где вы его используете.
В этом случае выход будет равен 1 2 3 4 5 .
Сведения об ответе
03:14, 1st August, 2020
Пожалуйста, не беспокойтесь о «efficiency» (скорость, действительно) из которых один быстрее. В наши дни у нас есть компиляторы, которые заботятся о таких вещах. Используйте тот из них, который имеет смысл использовать, исходя из которого более четко видно ваше намерение.
Сведения об ответе
DO__IT
01:34, 16th August, 2020
++i увеличивает значение, а затем возвращает его.
i++ возвращает значение,а затем увеличивает его.
Это очень тонкая разница.
Для цикла for используйте ++i , так как это немного быстрее. i++ создаст дополнительную копию,которая просто будет выброшена.
Сведения об ответе
PIRLO
00:33, 13th August, 2020
i++ :- в этом сценарии сначала присваивается значение, а затем происходит инкремент.
++i :- в этом сценарии сначала выполняется приращение, а затем присваивается значение
Ниже приведена визуализация изображения, а также здесь есть хорошее практическое видео ( http://www.youtube.com/watch?v=lrtcfgbUXm4), что демонстрирует то же самое.
Сведения об ответе
20:40, 10th August, 2020
Причина, по которой ++i может быть немного быстрее, чем i++ , заключается в том, что i++ может потребовать локальную копию значения i, Прежде чем оно будет увеличено, в то время как ++i никогда этого не делает. В некоторых случаях некоторые компиляторы будут оптимизировать его, если это возможно. но это не всегда возможно, и не все компиляторы делают это.
Я стараюсь не слишком полагаться на оптимизацию компиляторов, поэтому я бы последовал совету Райана Фокса: когда я могу использовать оба варианта, я использую ++i .
Сведения об ответе
12:49, 12th August, 2020
Эффективный результат использования любого из них идентичен. Другими словами, цикл будет делать то же самое точно в обоих случаях.
С точки зрения эффективности, может быть штраф, связанный с выбором i++ вместо ++i. с точки зрения спецификации языка, использование оператора post-increment должно создавать дополнительную копию значения, на которое действует оператор. Это может быть источником дополнительных операций.
Однако вы должны рассмотреть две основные проблемы с предыдущей логикой.
Современные компиляторы-это здорово. Все хорошие компиляторы достаточно умны, чтобы понять, что он видит целочисленное приращение в цикле for, и он оптимизирует оба метода для одного и того же эффективного кода. Если использование post-increment вместо pre-increment на самом деле приводит к тому, что ваша программа работает медленнее, то вы используете ужасный компилятор.
С точки зрения трудоемкости операции эти два метода (даже если копия действительно выполняется) эквивалентны. Количество инструкций, выполняемых внутри цикла, должно значительно превышать количество операций в операции инкремента. Таким образом, в любом цикле значительного размера штраф метода инкремента будет массово затенен выполнением тела цикла. Другими словами, вам гораздо лучше беспокоиться об оптимизации кода в цикле, а не о приращении.
На мой взгляд, весь вопрос просто сводится к стилевому предпочтению. Если вы считаете, что pre-increment более удобочитаем, то используйте его. Лично я предпочитаю пост-инкремент, но это, вероятно, потому, что это было то, чему меня учили до того, как я узнал что-либо об оптимизации.
Это типичный пример преждевременной оптимизации, и подобные проблемы могут отвлечь нас от серьезных проблем в дизайне. Однако это все еще хороший вопрос, потому что в «best practice.» нет единообразия в использовании или консенсуса
Объясните доступным языком разницу между инкрементами. В чем разница между ++i и i++?
++i возвращает значение уже измененной переменной
i++ возвращает значение переменной i до выполнения этого инкремента
Пример:
- Вконтакте
Например y = ++x, x с начало увеличится, затем присвоит значение y;
y = x++, x с начало присвоит значение, а затем только увеличится.
Что означает str [i — 1] == ''?
Я просматривал программу, которая использует первую букву каждого слова в строке с заглавной буквы. Например, «every single day» становится «Every Single Day» .
Я не понимаю часть str[i — 1] == ‘ ‘ . Что это значит?
6 ответов
i — это индекс в строке текущего символа, который вы собираетесь использовать с заглавной буквы (помните, что он начинается с 0).
i-1 — это индекс в строке от предыдущего символа к рассматриваемому вами.
str[i-1] — это символ в позиции, предшествующей рассматриваемой вами.
== ‘ ‘ сравнивает этот символ с пробелом.
Итак, str[i-1] == ‘ ‘ означает «Является ли символ слева от этого пробелом?»
Здесь вы сравниваете str[i-1] с символом space , код ASCII которого равен 32.
Выполните этот фрагмент, и если сравнение дает значение 1, оно истинно, в противном случае — ложно. Поставьте str[] = «Ryan Mney»; и сравните, вы поймете, что происходит?
‘ ‘ — символьная константа, представляющая значение символа пробела в наборе выполнения. Использование ‘ ‘ вместо 32 увеличивает как читаемость, так и переносимость в системы, в которых пробел может не иметь того же значения, что и в наборе символов ASCII. (i == 0 || str[i — 1] == ‘ ‘) истинно, если i — это смещение начала слова в списке слов, разделенных пробелами.
Важно постараться сделать его как можно более простым и читабельным. Использование магических констант, таких как 32 , не рекомендуется, если более выразительная альтернатива проста и дёшево. Например, вы конвертируете строчные символы в верхний регистр с помощью str[i] -= 32 : это магическое значение 32 (опять же!) Оказывается смещением между строчными и прописными символами. Было бы удобнее написать:
Точно так же вы написали тесты диапазона для нижнего и верхнего регистра в обратном порядке: это подвержено ошибкам и удивительно для читателя.
Вы также повторяете тест для начала слова: проверка на нижний регистр только в начале слова и проверка на верхний регистр в противном случае упрощает код.
Наконец, использование цикла for более кратко и менее подвержено ошибкам, чем цикл while в вашей функции, но я знаю, что местные правила кодирования в вашей школе запрещают циклы for (!) .
Вот модифицированная версия:
Обратите внимание, что в приведенном выше коде все еще предполагается, что буквы образуют два смежных блока в одном порядке от a до z . Это предположение справедливо для набора символов ASCII, который сегодня почти универсален, но лишь частично для набор EBCDIC все еще используется в некоторых системах мэйнфреймов, где существует постоянное смещение между регистрами, но буквы от a до z не образуют непрерывный блок.
Более общий подход будет использовать функции и макросы из <ctype.h> для проверки пробелов (пробелов и других пробелов), регистра символов и преобразования регистра:
‘ ‘ — это символьная константа для символа пробела (значение ASCII 32).
str — указатель на char в вызывающей стороне. (На практике он должен указывать на массив char со строкой внутри него, а не только на один char ).
Обратите внимание, что синтаксис C позволяет использовать нотацию массива для указателей. Таким образом, str[1] равно *(str + 1) .
[i — 1] в str[i — 1] означает, что вы получаете доступ к элементу до того, как указывает элемент str[i] .
Элемент str[i — 1] , на который указывает, сравнивается с символом пробела (если элемент str[i — 1] , на который указывает, действительно содержит пробел).
В этом случае условие оценивается как true , иначе условие равно false .
Обратите внимание, что str[i — 1] может быть опасным, когда i == 0 . Затем вы попытаетесь получить доступ к памяти за пределами указанного массива. Но в вашем случае это безопасно, поскольку str[i — 1] == ‘ ‘ оценивается только в том случае, если i == 0 не равно true , благодаря логическому ИЛИ || .
Так что этот случай учтен в вашем коде.
str[i] -= 32; эквивалентно str[i] -= ‘a’ — ‘A’; . Последняя форма может улучшить читаемость, поскольку основное внимание уделяется характеру использования заглавных букв.