pointer - c++:: operator




Was ist der Operator "->" in C++? (14)

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)

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?


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

Das ist genau das Gleiche wie

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

für nicht negative Zahlen


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.


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

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 ^^


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            

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
}

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".


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 ...


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;)


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


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

Die beiden Operatoren werden wie --> als einzelne Operatoren angewendet.


x kann in umgekehrter Richtung noch schneller gegen 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

;)







standards-compliance