В чем разница между префиксными и постфиксными операторами?
Следующий код печатает значение 9. Почему? Здесь return(i++)
вернет значение 11 и из-за --i
значение должно быть 10 само, может ли кто-нибудь объяснить, как это работает?
#include<stdio.h>
main()
{
int i= fun(10);
printf("%d\n",--i);
}
int fun (int i)
{
return(i++);
}
Ответы
Ответ 1
Существует большая разница между версиями постфикса и префикса ++
.
В префиксной версии (т.е. ++i
) значение i
увеличивается, а значение выражения - новое значение i
.
В постфиксной версии (т.е. i++
) значение i
увеличивается, но значение выражения представляет собой оригинальное значение i
.
Проанализируйте следующий код по строкам:
int i = 10; // (1)
int j = ++i; // (2)
int k = i++; // (3)
-
i
устанавливается на 10
(легко).
- Две вещи на этой линии:
-
i
увеличивается до 11
.
- Значение new
i
копируется в j
. Итак, j
теперь равно 11
.
- Две вещи на этой линии:
-
i
увеличивается до 12
.
- Значение оригинала
i
(которое равно 11
) копируется в k
. Итак, k
теперь равно 11
.
Итак, после запуска кода i
будет 12, но оба j
и k
будут равны 11.
То же самое относится к версиям постфикса и префикса --
.
Ответ 2
Функция возвращается до того, как i
увеличивается, потому что вы используете пост-исправный оператор (++). Во всяком случае, приращение i
не является глобальным - только для соответствующей функции. Если бы вы использовали оператор pre-fix, это было бы 11
, а затем уменьшалось до 10
.
Итак, вы возвращаете i
как 10 и уменьшаете его в функции printf, которая, как вы думаете, показывает 9
not 10
.
Ответ 3
Префикс:
int a=0;
int b=++a; // b=1,a=1
до присвоения значение будет увеличиваться.
Postfix:
int a=0;
int b=a++; // a=1,b=0
сначала назначьте значение 'a' на 'b', затем увеличьте значение 'a'
Ответ 4
Фактически return (i++)
будет возвращать только 10.
Операторы ++ и - могут быть размещены до или после переменной с различными эффектами. Если они раньше, то они будут обработаны и возвращены и, по существу, обработаны так же, как (i-1) или (i + 1), но если вы поместите ++ или - после i, то возврат будет essentailly
return i;
i + 1;
Таким образом, он вернет 10 и никогда не увеличит его.
Ответ 5
Приращение постфикса ++
не увеличивает значение его операнда до тех пор, пока оно не будет оценено. Значение i++
равно i
.
Приращение префикса увеличивает значение его операнда до его оценки. Значение --i
равно i - 1
.
Приращение/уменьшение префиксов изменяют значение перед вычислением выражения. Постерическое приращение/уменьшение изменяют значение после.
Итак, в вашем случае fun(10)
возвращает 10, а печать --i
печатает i - 1
, что равно 9.
Ответ 6
i ++ - это пост-приращение. Приращение происходит после возврата значения.
Ответ 7
Это связано с тем, как работает оператор post-increment. Он возвращает значение i, а затем увеличивает значение.
Ответ 8
Во-первых, обратите внимание, что параметр функции с именем i
и переменная с именем i
в main()
являются двумя разными переменными. Я думаю, что это не имеет большого значения для нынешней дискуссии, но важно знать.
Во-вторых, вы используете оператор postincrement в fun()
. Это означает, что результатом выражения является значение до i
увеличивается; окончательное значение 11 из i
просто отбрасывается, а функция возвращает 10. Переменной i
back в main, являющейся другой переменной, присваивается значение 10, которое затем уменьшается до 9.
Ответ 9
Фактически, что происходит, когда вы используете postfix i.e. я ++, начальное значение я используется для возврата, а не для инкремента. После этого значение я увеличивается на 1. И это происходит с любым оператором, который использует я ++, то есть первое начальное значение я используется в выражении, а затем оно увеличивается.
И все наоборот происходит в префиксе. Если бы вы вернули ++ i, то возвращается возвращаемое значение, т.е. 11, что связано с тем, что сначала выполняется добавление 1, а затем возвращается.
Ответ 10
Объяснение:
Шаг 1: int fun(int);
Здесь мы объявляем прототип функции fun()
.
Шаг 2: int i = fun(10);
Переменная я объявляется как целочисленный тип, а результат fun(10)
будет сохранен в переменной i
.
Шаг 3: int fun(int i){ return (i++); }
Внутри fun()
мы возвращаем значение return(i++)
. Он возвращает 10
. потому что i++
- это оператор после инкремента.
Шаг 4: Затем управление обратно к основной функции и значению 10
назначается переменной i
.
Шаг 5: printf("%d\n", --i);
Здесь --i
обозначается pre-increement. Следовательно, он печатает значение 9
.
Ответ 11
Есть два примера, иллюстрирующих разницу
int a , b , c = 0 ;
a = ++c ;
b = c++ ;
printf (" %d %d %d " , a , b , c++);
- Здесь c имеет значение 0 c с шагом в 1, затем присваивает значение 1 так
a = 1
и значение c = 1
-
следующее значение assiagn оператора c = 1
to b, затем увеличивайте c на 1 так, чтобы
значение b = 1
и значение c = 2
-
in printf
statement we c++
это означает, что оригинальное значение c
который будет отпечатан на 2, затем нарисуйте c на 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
Ответ 12
fun (10) возвращает 10. Если вы хотите, чтобы он вернул 11, вам нужно использовать ++ i, а не я ++.
int fun(int i)
{
return ++i;
}