Was ist der Operator "->" in C ++?

Nach der Lektüre Hidden Features und dunkle Ecken C ++ / STL auf comp.lang.c++.moderated, ich war völlig überrascht , dass die folgende Snippet erstellt und sowohl in Visual Studio 2008 und G ++ 4.4 gearbeitet.

Hier ist der Code:

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

Ausgabe:

9 8 7 6 5 4 3 2 1 0

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

-->ist kein Operator. Es sind in der Tat zwei getrennte Operatoren, --und >.

Der Code der Bedingung wird dekrementiert x, während der xursprüngliche (nicht dekrementierte) Wert zurückgegeben wird, und der ursprüngliche Wert wird dann mit der 0Verwendung des >Operators verglichen .

Zum besseren Verständnis könnte die Aussage wie folgt geschrieben werden:

while( (x--) > 0 )

Oder für etwas ganz anderes ... xrutscht zu 0.

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

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

Das ist ein sehr komplizierter Operator, daher hat sogar ISO / IEC JTC1 (Joint Technical Committee 1) seine Beschreibung in zwei verschiedenen Teilen des C ++ - Standards platziert.

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

Es ist gleichbedeutend mit

while (x-- > 0)

x--(nach dem Dekrementieren) entspricht x = x-1dem folgenden Code:

while(x > 0) {
    x = x-1;
    // logic
}
x--;   // The post decrement done when x <= 0

x kann in der entgegengesetzten Richtung noch schneller auf Null gehen:

int x = 10;

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

8 6 4 2

Sie können die Geschwindigkeit mit einem Pfeil steuern!

int x = 100;

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

90 80 70 60 50 40 30 20 10

;)

Es ist

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

     while( x-- > 0 ){ // x goes to 0

       printf("%d ", x);
     }

     return 0;
}

Allein der Platz lässt die Dinge lustig aussehen, --dekrementiert und >vergleicht.

Die Verwendung von -->hat historische Relevanz. Das Inkrementieren war (und ist in einigen Fällen immer noch) schneller als das Inkrementieren in der x86-Architektur. Die Verwendung -->schlägt vor, dass dies der xFall ist 0, und spricht diejenigen mit mathematischem Hintergrund an.

while( x-- > 0 )

So wird das analysiert.

Ä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;
}

In einem Buch, das ich gelesen habe (ich erinnere mich nicht richtig, welches Buch), heißt es: Compiler versuchen, Ausdrücke mithilfe der Regel von links nach rechts auf das größte Token zu analysieren .

In diesem Fall lautet der Ausdruck:

x-->0

Analysiert die größten Token:

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

Die gleiche Regel gilt für diesen Ausdruck:

a-----b

Nach dem Parsen:

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

Ich hoffe das hilft den komplizierten Ausdruck zu verstehen ^^

Dies ist genau das gleiche wie

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

für nicht negative Zahlen

Wie auch immer, wir haben jetzt einen "Gehe zu" -Operator. "-->"ist leicht als Richtung zu merken, und "während x auf Null geht" ist bedeutungsgerade.

Darüber hinaus ist es etwas effizienter als "for (x = 10; x > 0; x --)"auf einigen Plattformen.

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

9 8 7 6 5 4 3 2 1 0

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

Wenn wir zuerst dekrementieren und dann vergleichen möchten, 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

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

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

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

Wie erwartet. Das while( x-- > 0 )heißt eigentlich while( x > 0). Die x--Post dekrementiert x.

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

ist eine andere Art, dasselbe zu schreiben.

Es ist schön, dass das Original wie "während x auf 0 geht" aussieht.

Zwischen --und fehlt ein Leerzeichen >. xwird nach der Überprüfung des Zustands nachträglich dekrementiert, dh dekrementiert x>0 ?.

--ist der Dekrementierungsoperator und >der Größer-als- Operator.

Die beiden Operatoren werden wie ein einziger angewendet -->.

Es ist eine Kombination aus zwei Operatoren. Erstens --dient es 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            

Ist tatsächlich xnach dem Dekrementieren und wird mit dieser Bedingung überprüft. Es ist nicht -->, es ist(x--) > 0

Hinweis: Der Wert von xwird geändert, nachdem die Bedingung überprüft wurde, da er nach dem Dekrementieren erfolgt. Einige ähnliche Fälle können auch auftreten, zum Beispiel:

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

C und C ++ befolgen die "Maximum Munch" -Regel. Genauso wie a --- b übersetzt wird (a--) - b, in Ihrem Fall x-->0übersetzt in (x--)>0.

Die Regel besagt im Wesentlichen, dass Ausdrücke von links nach rechts gebildet werden, indem das Maximum an Zeichen verwendet wird, die einen gültigen Ausdruck bilden.

Warum all die Komplikationen?

Die einfache Antwort auf die ursprüngliche Frage lautet nur:

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

Macht das Gleiche. Das heißt nicht, dass Sie es so machen sollten, aber es macht das Gleiche und hätte die Frage in einem Beitrag beantwortet.

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

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

Auf herkömmliche Weise würden wir eine Bedingung in der whileSchleifenklammer ()und eine Abschlussbedingung in den geschweiften Klammern definieren {}, aber -->beide gleichzeitig definieren.

Zum Beispiel:

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

Dadurch wird adie Schleife dekrementiert und ausgeführt, solange sie agrößer als ist 0.

Herkömmlicherweise wäre es wie:

int abc(void)
{
    int a = 5;
    while(a > 0)
    {
        a--;
        // Code
    }
    a--;
}

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

(x --> 0) meint (x-- > 0)

1. Sie können verwenden (x -->)
output -: 9 8 7 6 5 4 3 2 1 0

2. Sie können verwenden (-- x > 0) Es ist gemein(--x > 0)
output -: 9 8 7 6 5 4 3 2 1

3. Sie können verwenden

(--\
    \
     x > 0)

output -: 9 8 7 6 5 4 3 2 1

4. Sie können verwenden

(\
  \
   x --> 0)

output -: 9 8 7 6 5 4 3 2 1 0

5. Sie können verwenden

(\
  \
   x --> 0
          \
           \
            )

output -: 9 8 7 6 5 4 3 2 1 0

6. Sie können auch verwenden

(
 x 
  --> 
      0
       )

output -: 9 8 7 6 5 4 3 2 1 0

Ebenso können Sie viele Methoden ausprobieren, um diesen Befehl erfolgreich auszuführen