В чем разница между префиксными и постфиксными операторами?

Question

Следующий код печатает значение 9. Почему?Здесь return(i++) вернет значение 11, а из-за --i само значение должно быть 10, кто-нибудь может объяснить, как это работает?

Answer 1

Существует разница большая между постфиксной и префиксной версиями ++.

В префиксной версии (т. Е. ++i) значение i увеличиваетсяи значением выражения является новое значение i.

В постфиксной версии (т. е. i++) значение i увеличивается, нозначение выражения является оригинальным значением i.

Давайте проанализируем следующий код строка за строкой:

int i = 10;   // (1)
int j = ++i;  // (2)
int k = i++;  // (3)

1. i10 (просто).
2. В этой строке две вещи:
   • i увеличивается до 11.
   • new значение i копируется в j.Поэтому j теперь равно 11.
3. В этой строке также есть две вещи:
   • i увеличивается до 12.
   • оригинал значение i (то есть 11) копируется в k.Таким образом, k теперь равно 11.

Так что после выполнения кода i будет 12, но и j и k будет 11.

То же самое относится к постфиксным и префиксным версиям --.

Answer 2

Префикс:

int a=0;

int b=++a;          // b=1,a=1 

перед присвоением значение будет увеличиваться.

Postfix:

int a=0;
int b=a++;  // a=1,b=0 

сначала присвойте значение 'a' значению 'b', затем увеличьте значение 'a'

Answer 3

Функция возвращается до того, как i увеличивается, потому что вы используете оператор пост-исправления (++).В любом случае, приращение i не является глобальным - только для соответствующей функции.Если бы вы использовали оператор предварительного исправления, он был бы 11, а затем уменьшен до 10.

Так что вы затем возвращаете i как 10 и уменьшаете его в функции printf, которая показывает1008 * не 10 как вы думаете.

Answer 4

Фактически return (i++) вернет только 10.

Операторы ++ и - могут быть помещены до или после переменной, с различными эффектами.Если они раньше, то они будут обработаны и возвращены и, по существу, будут обрабатываться точно так же, как (i-1) или (i + 1), но если вы поместите ++ или - после i, то возврат будет существенно

return i;
i + 1;

Таким образом, он вернет 10 и никогда не будет увеличивать его.

Answer 5

Постфиксный инкремент ++ не увеличивает значение своего операнда до тех пор, пока он не будет оценен.Значение i++ равно i.

Уменьшение префикса увеличивает значение его операнда до того, как будет оценено.Значение --i равно i - 1.

Увеличение / уменьшение префикса изменяет значение до вычисления выражения.Постфиксный приращение / уменьшение изменяет значение после.

Итак, в вашем случае fun(10) возвращает 10, и при печати --i печатается i - 1, что равно 9.

Answer 6

Есть два примера, иллюстрирующих разницу

int a , b , c = 0 ; 
a = ++c ; 
b = c++ ;
printf (" %d %d %d " , a , b , c++);

• Здесь c имеет значение 0 с шагом 1, затем присваивает значение 1 значению so a = 1 и значение c = 1

• значение следующего оператора, связанное с c = 1 до b, затем увеличить c на 1, так значение b = 1 и значение c = 2

• в printf заявлении у нас есть c++ это означает, что первоначальное значение c который равен 2, будет напечатан, а затем увеличится на 1, так что printf напечатает 1 1 2 и значение c теперь равно 3

вы можете использовать http://pythontutor.com/c.html

int a , b , c = 0 ; 
a = ++c ; 
b = c++ ;
printf (" %d %d %d " , a , b , ++c);

• Здесь в printf оператор ++c сначала увеличит значение c на 1, затем назначьте новое значение 3 для c, чтобы оператор printf напечатал 1 1 3

Answer 7

i ++ - постинкремент. Приращение происходит после того, как значение возвращено.

Answer 8

Пояснение:

Шаг 1: int fun(int); Здесь мы объявляем прототип функции fun().

Шаг 2: int i = fun(10); Переменная i объявлена ​​как целочисленный тип, и результат fun(10) будет сохранен в переменной i.

Шаг 3: int fun(int i){ return (i++); } Внутри fun() мы возвращаем значение return(i++). Возвращает 10. потому что i++ является оператором после инсерции.

Шаг 4: Затем управление возвращается к основной функции, и значение 10 присваивается переменной i.

Шаг 5: printf("%d\n", --i); Здесь --i обозначает предварительное слияние. Следовательно, он печатает значение 9.

Answer 9

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

И прямо противоположное происходит в префиксе. Если бы вы вернули ++ i, то возвращается увеличенное значение, т.е. 11, потому что сначала добавляется 1, а затем возвращается.

Answer 10

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

Во-вторых, вы используете оператор постинкремента в fun(). Это означает, что результатом выражения является значение до увеличения i; окончательное значение 11 из i просто отбрасывается, и функция возвращает 10. Переменной i обратно в main, являющейся другой переменной, присваивается значение 10, которое вы затем уменьшаете, чтобы получить 9.