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

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

#include<stdio.h>
main()
{
    int i= fun(10);
    printf("%d\n",--i);
}

int fun (int i)
{
    return(i++);
}
+23
источник поделиться
12 ответов

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

В префиксной версии (т.е. ++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.

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

+39
источник

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

Итак, вы возвращаете i как 10 и уменьшаете его в функции printf, которая, как вы думаете, показывает 9 not 10.

+10
источник
другие ответы

Связанные вопросы


Похожие вопросы

Префикс:

int a=0;

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

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

Postfix:

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

сначала назначьте значение 'a' на 'b', затем увеличьте значение 'a'

+10
источник

Фактически return (i++) будет возвращать только 10.

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

return i;
i + 1;

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

+7
источник

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

Приращение префикса увеличивает значение его операнда до его оценки. Значение --i равно i - 1.

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

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

+4
источник

i ++ - это пост-приращение. Приращение происходит после возврата значения.

+3
источник

Это связано с тем, как работает оператор post-increment. Он возвращает значение i, а затем увеличивает значение.

+2
источник

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

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

+2
источник

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

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

+2
источник

Объяснение:

Шаг 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.

+2
источник

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

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
+2
источник

fun (10) возвращает 10. Если вы хотите, чтобы он вернул 11, вам нужно использовать ++ i, а не я ++.

int fun(int i)
{
    return ++i;
}
+1
источник

Посмотрите другие вопросы по меткам или Задайте вопрос