operators &= - Was ist der Operator "->" in C++?




arrow pointer (18)

Die Verwendung von --> hat historische Relevanz. Das Dekrementieren war (und ist in einigen Fällen immer noch) schneller als das Inkrementieren der x86-Architektur. Die Verwendung von --> legt nahe, dass x auf 0 , und spricht diejenigen mit mathematischen Hintergründen an.

Nachdem ich Hidden Features und Dark Corners von C ++ / STL unter comp.lang.c++.moderated , war ich völlig überrascht, dass das folgende Snippet in Visual Studio 2008 und G ++ 4.4 kompiliert wurde.

Hier ist der Code:

#include <stdio.h>
int main()
{
    int x = 10;
    while (x --> 0) // x goes to 0
    {
        printf("%d ", x);
    }
}

Ich würde davon ausgehen, dass dies C ist, da es auch in GCC funktioniert. Wo ist das in der Norm definiert und woher kommt es?


Dieser Code vergleicht zuerst x und 0 und dekrementiert dann x. (Auch in der ersten Antwort wurde gesagt: Sie dekrementieren x und vergleichen dann x und 0 mit dem Operator > .) Sehen Sie die Ausgabe dieses Codes:

9 8 7 6 5 4 3 2 1 0

Wir vergleichen nun zuerst und dekrementieren dann, indem wir 0 in der Ausgabe sehen.

Wenn wir zuerst dekrementieren und dann vergleichen wollen, verwenden Sie diesen Code:

#include <stdio.h>
int main(void)
{
    int x = 10;

    while( --x> 0 ) // x goes to 0
    {
        printf("%d ", x);
    }
    return 0;
}

Diese Ausgabe ist:

9 8 7 6 5 4 3 2 1

Es ist gleichbedeutend mit

while (x-- > 0)

x-- (post x-- ) ist äquivalent zu x = x-1 daher wird der Code umgewandelt in:

while(x > 0) {
    x = x-1;
    // logic
}

Tatsächlich ist x nach Dekrementierung und mit dieser Bedingung wird geprüft. Es ist nicht --> , es ist (x--) > 0

Hinweis: Der Wert von x wird geändert, nachdem die Bedingung geprüft wurde, da sie nach dem Dekrementieren abnimmt. Einige ähnliche Fälle können auch auftreten, zum Beispiel:

-->    x-->0
++>    x++>0
-->=   x-->=0
++>=   x++>=0

Äußerster Geek, aber ich werde dies verwenden:

#define as ;while

int main(int argc, char* argv[])
{
    int n = atoi(argv[1]);
    do printf("n is %d\n", n) as ( n --> 0);
    return 0;
}

while( x-- > 0 )

So wird das analysiert.


Warum all die Komplikation?

Die einfache Antwort auf die ursprüngliche Frage lautet:

#include <stdio.h>
int main()
{
    int x = 10;
    while (x > 0) 
    {
        printf("%d ", x);
        x = x-1;
    }
}

Tut das gleiche Ich sage nicht, dass Sie es so machen sollen, aber es tut dasselbe und hätte die Frage in einem Beitrag beantwortet.

Das x-- ist nur eine Abkürzung für das Obige und > ist nur ein normaler Größer-als- operator . Kein großes Rätsel!

Es gibt zu viele Leute, die einfache Dinge heutzutage kompliziert machen;)


Es ist eine Kombination aus zwei Operatoren. First -- dient zum Dekrementieren des Werts und > zum Überprüfen, ob der Wert größer als der rechte Operand ist.

#include<stdio.h>

int main()
{
    int x = 10;

    while (x-- > 0)
        printf("%d ",x);

    return 0;
}

Die Ausgabe wird sein:

9 8 7 6 5 4 3 2 1 0            

Dies ist ein sehr komplizierter Operator, weshalb selbst ISO / IEC JTC1 (Joint Technical Committee 1) seine Beschreibung in zwei verschiedene Teile des C ++ - Standards aufteilte.

Spaß beiseite, sie sind zwei verschiedene Operatoren: -- und > beschrieben in § 5.2.6 / 2 und §5.9 des C ++ 03-Standards.


Auf herkömmliche Weise definieren wir die Bedingung in while-Klammern " () " und die Beendigungsbedingung innerhalb der geschweiften Klammern " {} ", aber dies -- & > ist eine Art, auf die alle auf einmal definiert werden. Für zB:

int abc(){
    int a = 5
    while((a--) > 0){ // Decrement and comparison both at once
        // Code
    }
}

Es sagt, dekrementiere a und führe die Schleife aus, bis a größer als 0

Anders hätte es sein sollen:

int abc(){
    int a = 5
    while(a > 0){
        // Code
        a = a -1 // Decrement inside loop
    }
}

In beiden Fällen machen wir dasselbe und erreichen dieselben Ziele.


Zwischen -- und > fehlt ein Leerzeichen. x wird nach dekrementiert, das heißt nach der Überprüfung der Bedingung x>0 ? dekrementiert x>0 ? .


Passt auf

--> ist kein Operator. Es handelt sich tatsächlich um zwei getrennte Operatoren -- und > .

Der Code der Bedingung dekrementiert x , während er den ursprünglichen (nicht dekrementierten) Wert von x zurückgibt, und vergleicht dann den ursprünglichen Wert mit 0 mit dem Operator > .

Zum besseren Verständnis könnte die Aussage folgendermaßen geschrieben werden:

while((x--) > 0)

Jedenfalls haben wir jetzt einen Operator "Geht zu". "-->" ist leicht als Richtung zu merken, und "solange x gegen Null geht" bedeutet "gerade".

Außerdem ist es auf einigen Plattformen etwas effizienter als "for (x = 10; x > 0; x --)" .


Oder für etwas ganz anderes ... x gleitet auf 0

while (x --\
            \
             \
              \
               > 0)
     printf("%d ", x);

Nicht so mathematisch, aber ... jedes Bild sagt mehr als tausend Worte ...


Mein Compiler druckt 9876543210 aus, wenn ich diesen Code ausführen.

#include <iostream>
int main()
{
    int x = 10;

    while( x --> 0 ) // x goes to 0
    {
        std::cout << x;
    }
}

Wie erwartet. Das while( x-- > 0 ) bedeutet eigentlich while( x > 0) . Das x-- post dekrementiert x .

while( x > 0 ) 
{
    x--;
    std::cout << x;
}

ist eine andere Art, das Gleiche zu schreiben.

Es ist schön, dass das Original zwar aussieht als "x geht auf 0".


Ein Buch, das ich gelesen habe (ich weiß nicht genau, welches Buch), stellte fest: Compiler versuchen, Ausdrücke mit Hilfe der Links-Rechts-Regel zum größten Token zu analysieren .

In diesem Fall lautet der Ausdruck:

x-->0

Parses zu größten Spielmarken:

token 1: x
token 2: --
token 3: >
token 4: 0
conclude: x-- > 0

Die gleiche Regel gilt für diesen Ausdruck:

a-----b

Nach der Analyse:

token 1: a
token 2: --
token 3: --
token 4: -
token 5: b
conclude: (a--)-- - b

Ich hoffe das hilft den komplizierten Ausdruck zu verstehen ^^


Das ist genau das Gleiche wie

while (x--)
{
   printf("%d ", x);
}

für nicht negative Zahlen


Es ist ein C- trigraph . ??! ist | , so ??!??! ist der Operator ||





c++ operators code-formatting standards-compliance