Dla i = 0, dlaczego (i + = i ++) jest równe 0?

Weź następujący kod (używany jako aplikacja konsolowa):

static void Main(string[] args)
{
    int i = 0;
    i += i++;
    Console.WriteLine(i);
    Console.ReadLine();
}

Wynik ito 0. Spodziewałem się 2 (podobnie jak niektórzy z moich kolegów). Prawdopodobnie kompilator tworzy jakąś strukturę, której wynikiem ijest zero.

Powodem, dla którego spodziewałem się 2, jest to, że według mojej oceny pierwsze zdanie zostanie ocenione najpierw, zwiększając i o 1. Następnie dodaje się do i. Ponieważ i ma już 1, dodaje 1 do 1. Więc 1 + 1 = 2. Oczywiście nie dzieje się tak.

Czy możesz wyjaśnić, co robi kompilator lub co dzieje się w czasie wykonywania? Dlaczego wynik wynosi zero?

Coś w rodzaju zrzeczenia się odpowiedzialności: Jestem absolutnie świadomy, że nie będziesz (i prawdopodobnie nie powinien) używać tego kodu. Wiem, że nigdy nie będę. Niemniej jednak uważam za interesujące wiedzieć, dlaczego działa w taki sposób i co dokładnie się dzieje.

To:

int i = 0;
i += i++

Można to zaobserwować podczas pracy (poniższe uproszczenie jest ogromne):

int i = 0;
i = i + i; // i=0 because the ++ is a postfix operator and hasn't been executed
i + 1; // Note that you are discarding the calculation result

To, co faktycznie się dzieje, jest bardziej zaangażowane - spójrz na MSDN, operatory inkrementacji i dekrementacji Postfiksa 7.5.9 :

Przetwarzanie w czasie wykonywania operacji zwiększania lub zmniejszania Postfiksa w postaci x ++ lub x-- składa się z następujących kroków:

• Jeśli x jest klasyfikowany jako zmienna:

  • x jest obliczane w celu utworzenia zmiennej.
  • Wartość x zostaje zapisana.
  • Wybrany operator jest wywoływany z zapisaną wartością x jako argumentu.
  • Wartość zwrócona przez operatora jest przechowywana w miejscu podanym na podstawie oceny x.
  • Zapisana wartość x staje się wynikiem operacji.

Zauważ, że ze względu na kolejność pierwszeństwa , postfiks ++występuje wcześniej += , ale wynik ostatecznie nie jest używany (ponieważ iużywana jest poprzednia wartość parametru ).

Dokładniejszy rozkład i += i++części, z których jest wykonany, wymaga, aby wiedzieć, że oba +=i ++nie są atomowe (to znaczy żadna z nich nie jest pojedynczą operacją), nawet jeśli wyglądają tak, jak są. Sposób ich realizacji obejmuje zmienne tymczasowe, kopie iprzed operacjami - po jednej dla każdej operacji. (Użyję nazw iAddi iAssignzmiennych tymczasowych używanych odpowiednio dla ++i +=).

A zatem bliższe przybliżenie tego, co się dzieje, to:

int i = 0;
int iAdd = i; // Copy of the current value of i, for ++
int iAssign = i; // Copy of the current value of i, for +=

i = i + 1; // i++ - Happens before += due to order of precedence
i = iAdd + iAssign;

Demontaż działającego kodu:

int i = 0;
  xor         edx, edx
  mov         dword ptr i, edx         // set i = 0
i += i++;
  mov         eax, dword ptr i         // set eax = i (=0)
  mov         dword ptr tempVar1, eax  // set tempVar1 = eax (=0)
  mov         eax, dword ptr i         // set eax = 0 ( again... why??? =\ )
  mov         dword ptr tempVar2, eax  // set tempVar2 = eax (=0)
  inc         dword ptr i              // set i = i+1 (=1)
  mov         eax, dword ptr tempVar1  // set eax = tempVar1 (=0)
  add         eax, dword ptr tempVar2  // set eax = eax+tempVar2 (=0)
  mov         dword ptr i, eax         // set i = eax (=0)

Kod ekwiwalentny

Kompiluje do tego samego kodu, co następujący kod:

int i, tempVar1, tempVar2;
i = 0;
tempVar1 = i; // created due to postfix ++ operator
tempVar2 = i; // created due to += operator
++i;
i = tempVar1 + tempVar2;

Demontaż drugiego kodu (aby udowodnić, że są takie same)

int i, tempVar1, tempVar2;
i = 0;
    xor         edx, edx
    mov         dword ptr i, edx
tempVar1 = i; // created due to postfix ++ operator
    mov         eax, dword ptr i
    mov         dword ptr tempVar1, eax
tempVar2 = i; // created due to += operator
    mov         eax, dword ptr i
    mov         dword ptr tempVar2, eax
++i;
    inc         dword ptr i
i = tempVar1 + tempVar2;
    mov         eax, dword ptr tempVar1
    add         eax, dword ptr tempVar2
    mov         dword ptr i, eax

Otwieranie okna demontażu

Większość ludzi nie wie, a nawet nie pamięta, że ​​może zobaczyć końcowy kod asemblera w pamięci za pomocą okna Visual Studio Disassembly . Pokazuje wykonywany kod maszynowy, nie jest to CIL.

Użyj tego podczas debugowania:

Debug (menu) -> Windows (submenu) -> Disassembly

Co się dzieje z postfix ++?

Postfiks ++ mówi, że chcielibyśmy zwiększyć wartość argumentu po ocenie ... że wszyscy wiedzą ... co nieco myli znaczenie słowa "po ocenie" .

Co więc oznacza „po ocenie” :

• inne zastosowania operandu w tym samym wierszu kodu muszą zostać zmienione:
  • a = i++ + i drugi i ma wpływ na przyrost
  • Func(i++, i) drugi ma wpływ
• inne zastosowania na tej samej linii dotyczą operatora zwarciowego, takiego jak ||i &&:
  • (false && i++ != i) || i == 0 na trzecie i nie ma wpływu i ++, ponieważ nie jest ono oceniane

Jakie jest zatem znaczenie i += i++;:?

To jest to samo co i = i + i++;

Kolejność oceny jest następująca:

1. Przechowuj i + i (czyli 0 + 0)
2. Przyrost i (i staje się 1)
3. Przypisz wartość kroku 1 do i (i staje się 0)

Nie chodzi o to, że przyrost jest odrzucany.

Jakie jest znaczenie i = i++ + i;:?

To nie to samo co w poprzednim przykładzie. Trzeci ima wpływ na przyrost.

Kolejność oceny jest następująca:

1. Przechowuj i (czyli 0)
2. Przyrost i (i staje się 1)
3. Przechowuj wartość kroku 1 + i (czyli 0 + 1)
4. Przypisz wartość kroku 3 do i (i staje się 1)

int i = 0;
i += i++;

jest oceniany w następujący sposób:

Stack<int> stack = new Stack<int>();
int i;

// int i = 0;
stack.Push(0);                   // push 0
i = stack.Pop();                 // pop 0 --> i == 0

// i += i++;
stack.Push(i);                   // push 0
stack.Push(i);                   // push 0
stack.Push(i);                   // push 0
stack.Push(1);                   // push 1
i = stack.Pop() + stack.Pop();   // pop 0 and 1 --> i == 1
i = stack.Pop() + stack.Pop();   // pop 0 and 0 --> i == 0

tzn. izmienia się dwukrotnie: raz przez i++wyrażenie i raz przez +=wyrażenie.

Ale operandy tego +=zdania są

• wartość iprzed oszacowaniem i++(po lewej stronie +=) i
• wartość iprzed obliczeniem i++(prawa strona +=).

Najpierw i++zwraca 0. Następnie izwiększa się o 1. Na koniec iustawia się wartość początkową, iktóra wynosi 0 plus i++zwrócona wartość , która również wynosi zero. 0 + 0 = 0.

Jest to po prostu od lewej do prawej, oddolna ocena abstrakcyjnego drzewa składni. Pod względem koncepcyjnym drzewo wyrażenia jest przemieszczane od góry do dołu, ale ocena jest rozwijana, gdy rekurencja pojawia się z powrotem na drzewie od dołu.

// source code
i += i++;

// abstract syntax tree

     +=
    /  \
   i    ++ (post)
         \
         i

Ocena rozpoczyna się od rozważenia węzła głównego +=. To jest główny składnik tego wyrażenia. Lewy argument operatora +=musi zostać oceniony, aby określić miejsce, w którym przechowujemy zmienną, i uzyskać wcześniejszą wartość, która wynosi zero. Następnie należy ocenić prawą stronę.

Prawa strona to ++operator inkrementacyjny . Ma jeden operand, iktóry jest oceniany zarówno jako źródło wartości, jak i miejsce, w którym wartość ma być przechowywana. Operator ocenia i, znajduje 0i konsekwentnie zapisuje 1w tej lokalizacji. Zwraca poprzednią wartość, 0zgodnie z semantyką zwracania poprzedniej wartości.

Teraz kontrola wraca do +=operatora. Ma teraz wszystkie informacje potrzebne do zakończenia operacji. Zna miejsce, w którym należy przechowywać wynik (miejsce przechowywania i), a także poprzednią wartość, i ma wartość, którą należy dodać do poprzedniej wartości, a mianowicie 0. Tak więc ikończy się na zero.

Podobnie jak Java, C # zdezynfekował bardzo asinine aspekt języka C, ustalając kolejność oceny. Od lewej do prawej, od dołu do góry: najbardziej oczywista kolejność, której koder może się spodziewać.

Ponieważ i++najpierw zwraca wartość, a następnie ją zwiększa. Ale po ustawieniu i na 1, ustawisz ponownie na 0.

Metoda przyrostowa wygląda mniej więcej tak

int ++(ref int i)
{
    int c = i;
    i = i + 1;
    return c;
}

Zasadniczo, kiedy dzwonisz i++, ijest to przyrost, ale w twoim przypadku zwracana jest pierwotna wartość, a 0 jest zwracane.

Prosta odpowiedź

int i = 0;
i += i++;
// Translates to:
i = i + 0; // because post increment returns the current value 0 of i
// Before the above operation is set, i will be incremented to 1
// Now i gets set after the increment,
// so the original returned value of i will be taken.
i = 0;

i ++ oznacza: zwróć wartość i TO następnie ją zwiększ.

i + = i ++ oznacza: Weź aktualną wartość i. Dodaj wynik i ++.

Dodajmy teraz i = 0 jako warunek początkowy. i + = i ++ jest teraz oceniany w następujący sposób:

1. Jaka jest aktualna wartość i? Jest 0. Zapisz go, abyśmy mogli dodać do niego wynik działania i ++.
2. Oceń i ++ (ocenia na 0, ponieważ jest to bieżąca wartość i)
3. Załaduj zapamiętaną wartość i dodaj do niej wynik kroku 2. (dodaj 0 do 0)

Uwaga: pod koniec kroku 2 wartość i wynosi w rzeczywistości 1. Jednak w kroku 3 odrzucasz ją, ładując wartość i przed jej zwiększeniem.

W przeciwieństwie do i ++, ++ i zwraca wartość przyrostową.

Dlatego i + = ++ dałbym ci 1.

Operator przyrostowy post fix ++, nadaje zmiennej wartość w wyrażeniu, a następnie wykonaj przypisanyi przyrost zwrócił zero (0) do wartości, która zastępuje przyrostową (1) , więc otrzymujesz zero. Możesz przeczytać więcej o operatorze przyrostowym w ++ Operator (MSDN).

i += i++;będzie równa zero, ponieważ robi to ++później.

i += ++i; zrobi to wcześniej

Postfiks ++ ocenia iprzed zwiększeniem i +=ocenia tylko iraz.

Dlatego 0 + 0 = 0, tak jak ijest obliczane i używane przed inkrementacją, ponieważ ++stosowany jest format Postfiks . Aby uzyskać iprzyrost, najpierw użyj prefiksu form ( ++i).

(Również uwaga: powinieneś dostać tylko 1, ponieważ 0 + (0 + 1) = 1)

Odnośniki: http://msdn.microsoft.com/en-us/library/sa7629ew.aspx (+ =)
http://msdn.microsoft.com/en-us/library/36x43w8w.aspx (++)

Co robi C # i „dlaczego” zamieszania

Spodziewałem się również, że wartość będzie wynosić 1 ... ale niektóre eksploracje tej kwestii wyjaśniły pewne punkty.

Rozważ następujące metody:

    static int SetSum(ref int a, int b) { return a += b; }

    static int Inc(ref int a) { return a++; }

Spodziewałem się, że i += i++będzie tak samo jak SetSum(ref i, Inc(ref i)). Wartość i po tej instrukcji wynosi 1 :

int i = 0;
SetSum(ref i, Inc(ref i));
Console.WriteLine(i); // i is 1

Ale potem doszedłem do innego wniosku ... w i += i++rzeczywistości jest taki sam jak i = i + i++... więc stworzyłem inny podobny przykład, używając tych funkcji:

    static int Sum(int a, int b) { return a + b; }

    static int Set(ref int a, int b) { return a = b; }

Po wywołaniu tego Set(ref i, Sum(i, Inc(ref i)))wartość i wynosi 0 :

int i = 0;
Set(ref i, Sum(i, Inc(ref i)));
Console.WriteLine(i); // i is 0

To nie tylko wyjaśnia, co robi C # ... ale także dlaczego wielu ludzi się z tym myliło ... w tym ja.

Dobry mnemonik, o którym zawsze pamiętam, jest następujący:

Jeśli ++stoi po wyrażeniu, zwraca wartość, którą był wcześniej . Więc następujący kod

int a = 1;
int b = a++;

wynosi 1, ponieważ abyło 1, zanim wzrosło o ++pozycję po a . Ludzie nazywają to notowanie poprawek postów . Istnieje również notacja przed poprawką, w której sytuacja jest dokładnie odwrotna: jeśli ++stoi przed , wyrażenie zwraca wartość taką, jaka jest po operacji:

int a = 1;
int b = ++a;

b jest tu dwa.

To oznacza dla twojego kodu

int i = 0;
i += (i++);

i++zwraca 0 (jak opisano powyżej), więc 0 + 0 = 0.

i += (++i); // Here 'i' would become two

Scott Meyers opisuje różnicę między tymi dwoma notacjami w „Efektywnym programowaniu w C ++”. Wewnętrznie i++(Postfix) pamięta wartość ibyła i wywołuje prefix-notację ( ++i) i zwraca starą wartość i. Dlatego zawsze powinieneś używać ++iw forpętlach (chociaż myślę, że wszystkie współczesne kompilatory tłumaczą i++się ++iw forpętlach).

Jedyną prawidłową odpowiedzią na twoje pytanie jest: Ponieważ jest niezdefiniowana.

Ok, zanim wszyscy mnie spalicie ...

Wszyscy odpowiedzieliście, dlaczego wynik i+=i++jest w porządku i logiczny i=0.

Kusiło mnie, by oddać głos za każdą z twoich odpowiedzi, ale obliczona przeze mnie reputacja byłaby zbyt wysoka.

Dlaczego jestem taki zły na was, ludzie? nie z powodu tego, co wyjaśniają twoje odpowiedzi.
Chodzi mi o to, że każda odpowiedź, którą przeczytałem, podjęła niezwykły wysiłek, aby wyjaśnić niemożliwe, ja brawa!

Ale jaki jest wynik? czy to wynik intuicyjny - czy jest to wynik akceptowalny?

Każdy z was widział „nagiego króla” i jakoś zaakceptował go jako racjonalnego króla.

Wszyscy jesteście ŹLE!

i+=i++;wynik w 0jest niezdefiniowany.

błąd w mechanizmie oceny języka, jeśli chcesz ... lub nawet gorzej! błąd w projekcie.

chcesz dowód? oczywiście, że chcesz!

int t=0; int i=0; t+=i++; //t=0; i=1

To jest ... intuicyjny wynik! ponieważ najpierw oceniliśmy tprzypisano mu wartość i dopiero po dokonaniu oceny i przypisaniu mieliśmy do czynienia z operacją po - racjonalne, prawda?

czy to racjonalne, że: i=i++i i=idać taki sam wynik i?

podczas t=i++i t=imają różne wyniki dla i.

Operacja po jest czymś, co powinno się wydarzyć po ocenie instrukcji.
W związku z tym:

int i=0;
i+=i++;

Powinno być tak samo, gdybyśmy napisali:

int i=0;
i = i + i ++;

i dlatego taki sam jak:

int i=0;
i= i + i;
i ++;

i dlatego taki sam jak:

int i=0;
i = i + i;
i = i + 1;

Jakikolwiek wynik, który nie 1wskazuje na błąd w kompilatorze lub błąd w projekcie języka, jeśli idziemy z racjonalnym myśleniem - jednak MSDN i wiele innych źródeł mówi nam „hej - to jest niezdefiniowane!”

Teraz, zanim przejdę dalej, nawet ten zestaw przykładów, które podałem, nie jest przez nikogo wspierany ani uznawany. Jednak to, co według intuicyjnego i racjonalnego sposobu powinno być wynikiem.

Koder nie powinien mieć wiedzy na temat pisania lub tłumaczenia zestawu.

Jeśli jest napisany w sposób niezgodny z definicjami języka - to błąd!

Na koniec skopiowałem to z Wikipedii, Operatory inkrementacji i dekrementacji :
Ponieważ operator inkrementacji / dekrementacji modyfikuje operand, użycie takiego operandu więcej niż jeden raz w ramach tego samego wyrażenia może dawać nieokreślone wyniki . Na przykład w wyrażeniach takich jak x - ++ x nie jest jasne, w jakiej kolejności należy wykonać operatory odejmowania i inkrementacji. Takie sytuacje są jeszcze gorsze, gdy kompilator stosuje optymalizacje, co może spowodować, że kolejność wykonywania operacji będzie inna niż zamierzona przez programistę.

I dlatego.

Prawidłowa odpowiedź brzmi: NIE NALEŻY UŻYWAĆ! (ponieważ jest NIEDEFINIOWANY!)

Tak .. - Ma nieprzewidywalne wyniki, nawet jeśli kompilator C # próbuje jakoś go znormalizować.

Nie znalazłem żadnej dokumentacji C # opisującej zachowanie, które wszyscy udokumentowaliście jako normalne lub dobrze zdefiniowane zachowanie języka. To, co znalazłem, jest dokładnie odwrotne!

[ skopiowane z dokumentacji MSDN dla operatorów przyrostowych i zmniejszających Postfix: ++ i - ]

Gdy operator postfiksu jest stosowany do argumentu funkcji, nie można zagwarantować , że wartość argumentu będzie zwiększana lub zmniejszana przed przekazaniem jej do funkcji. Więcej informacji znajduje się w sekcji 1.9.17 standardu C ++.

Zwróć uwagę, że te słowa nie są gwarantowane ...

Wybacz mi, jeśli ta odpowiedź wydaje się arogancka - nie jestem arogancką osobą. Po prostu uważam, że tysiące ludzi przyjeżdżają tutaj, aby się uczyć, a odpowiedzi, które czytam, wprowadzą ich w błąd i zaszkodzą ich logice i zrozumieniu tematu.

Operator ++ po zmiennej powoduje, że jest to przyrost postfiksowy. Inkrementacja następuje po wszystkim innym w instrukcji, dodawaniu i przypisywaniu. Jeśli zamiast tego wstawisz ++ przed zmienną, stanie się to przed oszacowaniem wartości i i otrzymasz oczekiwaną odpowiedź.

Kroki w obliczeniach to:

1. int i=0 // Zainicjowano na 0
2. i+=i++ //Równanie
3. i=i+i++ // po uproszczeniu równania przez kompilator
4. i=0+i++ // i podstawienie wartości
5. i=0+0 // i ++ ma wartość 0, jak wyjaśniono poniżej
6. i=0 // Wynik końcowy i = 0

Tutaj początkowo wartość iwynosi 0. WKT, i++jest niczym innym jak: najpierw użyj iwartości, a następnie zwiększ iwartość o 1. Więc używa iwartości 0, podczas obliczania, i++a następnie zwiększa ją o 1. Więc daje wartość z 0.

Istnieją dwie opcje:

Pierwsza opcja: jeśli kompilator przeczyta instrukcję w następujący sposób,

i++;
i+=i;

wynik to 2.

Dla

else if
i+=0;
i++;

wynik to 1.

Bądź bardzo ostrożny: przeczytaj C FAQ : to, co próbujesz zrobić (mieszanie przypisania i ++tej samej zmiennej) jest nie tylko nieokreślone, ale także niezdefiniowane (co oznacza, że ​​kompilator może zrobić cokolwiek podczas oceny !, nie tylko dając „uzasadnione” wyniki).

Przeczytaj rozdział 3 . Cały rozdział jest wart przeczytania! Zwłaszcza 3,9, co wyjaśnia implikację nieokreślonego. Sekcja 3.3 zawiera krótkie podsumowanie tego, co możesz, a czego nie możesz zrobić, używając „i ++” i tym podobnych.

W zależności od wewnętrznych kompilatorów, możesz dostać 0, 2, 1, a nawet cokolwiek innego! A ponieważ jest nieokreślony, jest w stanie to zrobić.

W powyższych odpowiedziach jest wiele doskonałych argumentów, właśnie wykonałem mały test i chcę się z tobą podzielić

int i = 0;
i+ = i++;

Tutaj wynik i pokazuje 0 wynik. Teraz rozważ poniższe przypadki:

Przypadek 1:

i = i++ + i; //Answer 1

wcześniej myślałem, że powyższy kod jest podobny do tego, więc na pierwszy rzut oka odpowiedź wynosi 1, a tak naprawdę odpowiedź i dla tego jednego to 1.

Przypadek 2:

i = i + i++; //Answer 0 this resembles the question code.

tutaj operator przyrostu nie pojawia się na ścieżce wykonania, w przeciwieństwie do poprzedniego przypadku, w którym i ++ ma szansę wykonać przed dodaniem.

Mam nadzieję, że to trochę pomoże. Dzięki

Mam nadzieję odpowiedzieć na to z perspektywy programowania typu 101.

Wygląda mi na to, że dzieje się w tej kolejności:

1. ijest oceniany jako 0, co powoduje, i = 0 + 0że operacja przyrostowa jest i++„w kolejce”, ale przypisanie 0 do ijeszcze się nie zdarzyło.
2. Przyrost i++zachodzi
3. Przypisanie i = 0z wyżej dzieje, skutecznie nadpisywania niczego, nr 2 (post-inkrementacja) zrobiłby.

Teraz # 2 może się nigdy nie wydarzyć (prawdopodobnie nie?), Ponieważ kompilator prawdopodobnie zdaje sobie sprawę, że nie będzie miał żadnego celu, ale może to zależeć od kompilatora. Tak czy inaczej, inne, bardziej kompetentne odpowiedzi wykazały, że wynik jest poprawny i zgodny ze standardem C #, ale nie jest określone, co się tutaj dzieje dla C / C ++.

Jak i dlaczego wykraczam poza moje doświadczenie, ale fakt, że poprzednio ocenione zadanie po prawej stronie dzieje się po zwiększeniu, jest prawdopodobnie mylące.

Co więcej, nie spodziewałbyś się, że wynik będzie równy 2, chyba że zrobisz to ++izamiast w i++to wierzę.

Po prostu,

i ++, doda 1 do „i” po zakończeniu operatora „+ =”.

To czego potrzebujesz to ++ i, aby dodać 1 do „i” przed wykonaniem operatora „+ =”.

i=0

i+=i

i=i+1

i=0;

Następnie dodaje się 1 do i.

i + = i ++

Tak aby przed dodaniem 1 i, iwziął wartość 0. Tylko jeśli dodamy 1 przed, iuzyskać wartość 0.

i+=++i

i=2

Odpowiedź ibędzie 1.

Zobaczmy, jak:

Początkowo i=0;.

Następnie podczas obliczania i +=i++;według wartości będziemy mieli coś podobnego 0 +=0++;, więc według operatora pierwszeństwo 0+=0zostanie wykonane jako pierwsze, a wynik będzie 0.

Następnie operator przyrostu zostanie zastosowany jako 0++, as, 0+1a wartość ibędzie 1.