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

8925

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?

GManNickG
quelle
503
Oder auch nur den richtigen Abstand ... Ich glaube nicht, dass ich jemals ein Leerzeichen zwischen der Variablen und entweder ++oder --vorher gesehen habe ...
Matthew Scharley
1154
Dieser "Gehe zu" -Operator kann zurückgesetzt werden (0 <- x). Außerdem gibt es einen Operator "Läuft zu" (0 <---- x). Meine Güte, das lustigste, was ich je von c ++ Syntax gehört habe =) +1 für die Frage.
SadSido
233
Obwohl die Interpretation sehr falsch ist, beschreibt sie komischerweise, was der Code richtig macht. :)
Noldorin
811
Stellen Sie sich die neuen Syntaxmöglichkeiten vor: #define upto ++<, #define downto -->. Wenn Sie das Gefühl übel, können Sie tun , #define for while(und #define do ) {(und #define done ;}) und schreiben for x downto 0 do printf("%d\n", x) doneOh, die Menschheit ...
Chris Lutz
98
Öffnet die Möglichkeit einer völlig neuen ausdrucksstarken Codierungsmethode, bei der es sich lohnt, einige Compiler-Warnungen zu opfern für: bool CheckNegative (int x) {return x <0? wahr falsch ); }
ttt

Antworten:

8603

-->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 )
Potatoswatter
quelle
262
Andererseits sieht es in diesem Zusammenhang wie eine Art Bereichsoperator aus.
Charles Salvia
109
Zu sagen, dass x nach dem Dekrementieren und dann mit 0 verglichen wird, ist dasselbe wie zu sagen, dass x nach dem Vergleich mit 0 dekrementiert wird
Charles Salvia
8
Ich denke nicht, dass es das gleiche ist. Ich denke, das Wort "dann" impliziert, dass es eine Reihenfolge gibt (nach dem Dekrementieren ist der Wert von x eins weniger). Ich denke, man kann sagen "Sie dekrementieren x nach dem Dekrementieren und vergleichen dann seinen alten Wert mit 0 ...", um es klarer zu machen. Aber das ist sowieso ein Trottel. Wir alle wissen, was gemeint ist.
Johannes Schaub - litb
38
In Java kompiliert es auch :)
Steven Devijver
44
Der Name dafür, @Jay, ist ein schlechter Programmierstil :-) Dies wird durch die Tatsache belegt, dass die Frage überhaupt gestellt wurde. Es ist viel sinnvoller, Operatoren textuell an das zu binden, an dem sie arbeiten, als an etwas, das nichts damit while (x-- > 0)zu tun hat . Es macht auch deutlicher, was vor sich geht (zumindest in einem Editor mit fester Schriftart), was bedeutet, dass die Klammern in dieser Antwort nicht erforderlich wären.
Paxdiablo
3131

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

synchronisiert
quelle
216
@mafutrct - Wie ich mich erinnere, wird in C nur die nächste Zeile angehängt, als ob es keinen Zeilenumbruch gäbe. Die hier machen im Grunde nichts.
Hogan
2
@mafu Das Zeichen '\' teilt dem Compiler mit, dass die aktuelle Zeile in der nächsten Zeile fortgesetzt wird. Daher sollte der Compiler beide Zeilen zusammenführen und als eine kompilieren. 'while (x -> 0)' wird ausgeführt, bis x gleich -1 ist. Aber die Art und Weise, wie er die Einrückungen macht, lässt es so aussehen, als würde x auf Null gleiten. 'Während x auf 0 gleitet ...'
Felype
16
IIRC, K & R C erlaubten Leerzeichen zwischen den '-'s im Dekrement-Operator. In diesem Fall könnten sich die Backslashes in der Mitte befinden, was noch cooler aussehen würde. :)
Jules
10
@ArnavBorborah ist eine alte Ausdrucksbedeutung why waste words when a picture does a better job, die in diesem Zusammenhang als Witz verwendet wird. (Es gibt in der Tat 2 Schlüsselwörter whileund printf)
synchronisiert
88
Ach ja, der obskure Dia-Operator. Wie könnte ich vergessen!
Demonkoryu
2377

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.

Kirill V. Lyadvinsky
quelle
1277

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
Shubham
quelle
15
Das ist nicht ganz richtig. Der Wert von x innerhalb des Schleifenkörpers ist im zweiten Fall unterschiedlich. Die Zuweisungsanweisung in Ihrem Beispiel sollte über der Logik liegen, damit sie äquivalent ist. Postfix - subtrahiert 1, aber der Vergleich erfolgt mit dem Wert vor der Subtraktion.
uliwitness
4
@uliwitness Diese sind wirklich gleichwertig. Es wäre falsch, wenn ein Präfix verwendet würde: 0 >-- xIn diesem Fall xwird vor der Logik dekrementiert. In Postfix wird die Logik vor dem Dekrement ausgeführt und somit sind beide Abtastwerte äquivalent. Fühlen Sie sich frei, sie in a zu schreiben Consoleund zu testen.
Candleshark
12
Sie sind immer noch nicht gleichwertig. Nach der ersten Schleife ist x -1 (oder überläuft, falls es nicht vorzeichenbehaftet ist), nach der zweiten ist es 0. (Angenommen, x beginnt nicht negativ, ändert keine Schleife x oder bricht oder ...)
Caesar
1
while(x=x-1,x+1 > 0)ist gleichwertig.
SS Anne
2
@Shebham, hier ist ein Zählerbeispiel: Wenn x als 0 beginnt, wird es unter der ursprünglichen Schleife als -1 beendet, bei Ihrer Version bleibt es Null. Sie sind also nicht gleichwertig.
Elliott
1208

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

;)

doc
quelle
6
Welches Betriebssystem, diese Art der Ausgabe generiert, verwende ich ein Ubuntu 12.04, in dem ich eine Fehlermeldung hatte
Bhuvanesh
74
Obwohl es offensichtlich sein sollte, dass jeder, der neu in C ++ ist, dies liest: Tu es nicht. Verwenden Sie einfach die erweiterte Zuweisung, wenn Sie mehr als eine Zuweisung / Dekrementierung benötigen.
Blimeo
263
Null mit "Lasern". while (0> - - - - - - - - - - - ---------- x) ... gleiche Ausgabe.
Samuel Danielson
4
@phord bist du sicher, dass es nicht kompiliert wird? -> coliru.stacked-crooked.com/a/5aa89a65e3a86c98
doc
18
@doc Es wird in c ++ kompiliert, aber nicht in c.
Phord
548

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.

RageZ
quelle
431

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.

Matt Joiner
quelle
479
Nicht genau richtig. Das Dekrementieren und Inkrementieren dauert gleich lange. Dies hat den Vorteil, dass der Vergleich mit Null im Vergleich zum Vergleich mit einer Variablen sehr schnell ist. Dies gilt für viele Architekturen, nicht nur für x86. Alles mit einem JZ-Befehl (Sprung, wenn Null). Beim Stöbern finden Sie viele "for" -Schleifen, die rückwärts geschrieben wurden, um Zyklen beim Vergleich zu speichern. Dies ist unter x86 besonders schnell, da beim Dekrementieren der Variablen das Null-Flag entsprechend gesetzt wird, sodass Sie dann verzweigen können, ohne die Variable explizit vergleichen zu müssen.
Burito
25
Wenn Sie gegen Null dekrementieren, müssen Sie nur mit 0 pro Schleifeniteration vergleichen, während Sie gegen n iterieren müssen, um mit n jeder Iteration zu vergleichen. Ersteres ist in der Regel einfacher (und wird bei einigen Architekturen nach jeder Datenregisteroperation automatisch getestet).
Joey Adams
9
@burrito Obwohl ich nicht anderer Meinung bin, werden Schleifen, die auf Werte ungleich Null konditioniert sind, im Allgemeinen nahezu perfekt vorhergesagt.
Duncan
14
Inkrementieren und Dekrementieren sind gleich schnell, wahrscheinlich auf allen Plattformen (definitiv auf x86). Der Unterschied besteht darin, die Schleifenendbedingung zu testen. Um zu sehen, ob der Zähler Null erreicht hat, ist er praktisch frei. Wenn Sie einen Wert dekrementieren, wird im Prozessor ein Null-Flag gesetzt. Um die Endbedingung zu erkennen, müssen Sie nur dieses Flag überprüfen, während beim Inkrementieren eine Vergleichsoperation vor der Endbedingung erforderlich ist erkannt werden kann.
Lego
7
Natürlich ist all dies heutzutage umstritten, da moderne Compiler Schleifen automatisch vektorisieren und umkehren können.
Lambda Fairy
366
while( x-- > 0 )

So wird das analysiert.

Grumdrig
quelle
362

Ä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;
}
Arrieta
quelle
17
@ SAFX - Es wäre perfekt Hieroglyphen mit ägyptischen Klammern
Mouviciel
1
Dies wird nicht kompiliert. C ist nicht Pascal, wobei das Innere von do ... whileeine Anweisungsliste ist. In C ist es ein Block, also muss es sein do { ... } while.
user207421
25
@EJP kompiliert es. Die Syntax lautet do statement while ( expression ) ;. Trotzdem hoffe ich, dass ich das Beispiel als Witz verstanden habe.
Escualo
321

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

NguyenDat
quelle
98
Ihre zweite Erklärung ist nicht korrekt. Der Compiler wird sehen a-----bund denken (a--)-- - b, was nicht kompiliert wird, weil a--es keinen l-Wert zurückgibt.
Tim Leaf
22
Zusätzlich xund --sind zwei separate Token.
Roland Illig
23
@DoctorT: Es passiert den Lexer. Nur ein semantischer Durchgang kann diesen Fehler auslösen. also ist seine Erklärung richtig.
v.oddou
9
Solange Sie denken, dass -->es sich um einen Operator handelt (was durch die gestellte Frage impliziert wird), ist diese Antwort überhaupt nicht hilfreich - Sie werden denken, Token 2 ist es -->nicht nur --. Wenn Sie wissen, dass dies -->kein Operator ist, haben Sie wahrscheinlich kein Problem damit, den Code in der Frage zu verstehen. Wenn Sie also keine völlig andere Frage haben, bin ich mir nicht sicher, wie dies nützlich sein könnte.
Bernhard Barker
4
Das Beispiel @DoctorT kann korrekt sein, wenn der aOperator nach dem Dekrementieren überladen ist, der lvalue zurückgibt. coliru.stacked-crooked.com/a/e1effc351ae79e9f
doc
275

Dies ist genau das gleiche wie

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

für nicht negative Zahlen

gute Person
quelle
153
Sollte das nicht sein for(--x++;--x;++x--)?
Mateen Ulhaq
9
@ DoctorT das ist, was unsignedist für
Cole Johnson
12
@MateenUlhaq, das ist nach dem Standard falsch, der Ausdruck --x++hat undefiniertes Verhalten gemäß §1.9.15
WorldSEnder
Wenn es verwendet hätte unsigned, hätte es verwendet%u
Cacahuete Frito
242

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.

Test
quelle
17
Kann nicht immer wahr sein, besonders wenn der Wert von x negativ ist.
Ganesh Gopalasubramanian
15
Die andere Version macht nicht dasselbe - mit for (size_t x=10; x-->0; )dem Körper der Schleife wird mit 9,8, .., 0 ausgeführt, während die andere Version 10,9, .., 1 hat. Andernfalls ist es ziemlich schwierig, eine Schleife mit einer vorzeichenlosen Variablen auf Null zu verlassen.
Pete Kirkham
4
Ich denke, das ist ein bisschen irreführend ... Wir haben keinen wörtlich "geht an" -Operator, da wir einen anderen brauchen ++>, um die inkrementelle Arbeit zu erledigen.
Tslmy
19
@Josh: Eigentlich gibt Überlauf undefiniertes Verhalten für int, so dass es Ihren Hund genauso leicht fressen kann wie xauf Null nehmen , wenn er negativ anfängt.
SamB
3
Dies ist eine sehr wichtige Redewendung für mich aus dem im Comnmet von @PeteKirkham angegebenen Grund, da ich häufig abnehmende Schleifen über vorzeichenlose Mengen bis hin zu durchführen muss 0. (Zum Vergleich: Die Redewendung, Tests für Null wegzulassen, wie z. B. das Schreiben while (n--)für unsignierte Tests n, kauft Ihnen nichts und beeinträchtigt für mich die Lesbarkeit erheblich.) Es hat auch die angenehme Eigenschaft, dass Sie einen mehr als den Anfangsindex angeben , was normalerweise der Fall ist Sie möchten (z. B. für eine Schleife über ein Array geben Sie dessen Größe an). Ich mag es auch -->ohne Platz, da dadurch die Redewendung leicht zu erkennen ist.
Marc van Leeuwen
221

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
SjB
quelle
177

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.

cool_me5000
quelle
4
Das Ergebnis ist nur dann undefiniert, wenn Sie dieselbe Variable mehr als einmal in derselben Anweisung inkrementieren / dekrementieren. Dies gilt nicht für diese Situation.
Tim Leaf
13
while( x-- > 0 ) actually means while( x > 0)- Ich bin mir nicht sicher, was Sie dort sagen wollten, aber die Art und Weise, wie Sie es formuliert haben, impliziert, dass das --überhaupt keine Bedeutung hat, was offensichtlich sehr falsch ist.
Bernhard Barker
Um den Punkt von @Dukeling nach Hause zu bringen, ist diese Antwort nicht dieselbe wie der ursprüngliche Beitrag. Im ursprünglichen Beitrag xwird, -1nachdem es die Schleife verlassen hat, während in dieser Antwort sein xwird 0.
Mark Lakata
148

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

Herr X.
quelle
42
Der Leerzeichen fehlt nicht - C (++) ignoriert Leerzeichen.
27
@ H2CO3 Dies ist im Allgemeinen nicht wahr. Es gibt Stellen, an denen Leerzeichen verwendet werden müssen, um Token zu trennen, z . B. im #define foo()Versus #define foo ().
Jens
30
@Jens Wie wäre es mit: "Der Leerzeichen fehlt nicht - C (++) ignoriert unnötigen Leerraum."?
Kevin P. Rice
139

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

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

muntoo
quelle
11
Sie werden als die 2 separaten Operatoren angewendet , die sie sind. Sie sind nur irreführend geschrieben , um wie "eine einzige" auszusehen.
underscore_d
129

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            
Rajeev Das
quelle
122

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
AndroidLearner
quelle
6
Nur dass ++> in einer Weile kaum noch verwendet werden kann (). Ein Operator "geht bis ..." wäre ++ <, was nirgendwo so gut aussieht. Der Betreiber -> ist ein glücklicher Zufall.
Florian F
2
@BenLeggiero Das könnte in dem Sinne funktionieren, dass Code generiert wird, der etwas bewirkt (während Leser wütend gemacht werden, die keinen faux-cleveren Code mögen), aber die Semantik ist unterschiedlich, da die Verwendung von Vorkürzungen bedeutet, dass eine Iteration weniger ausgeführt wird. Als erfundenes Beispiel würde es niemals den Schleifenkörper ausführen, wenn es xbei 1 gestartet while ( (x--) > 0 )würde , sondern würde es tun. {edit} Eric Lippert behandelte beide in seinen C # 4- Versionshinweisen
underscore_d
120

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.

Peter Mortensen
quelle
5
Welches ist, was das OP angenommen hat: dass "((a) ->)" das maximale Knabbern war. Es stellt sich heraus, dass die ursprüngliche Annahme des OP falsch war: "->" ist kein maximal gültiger Operator.
David
4
Wird auch als gieriges Parsen bezeichnet, wenn ich mich richtig erinnere.
Roy Tinker
1
@ RoyTinker Gieriges Scannen. Der Parser hat damit nichts zu tun.
user207421
27

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

Garry_G
quelle
17
Diese Frage handelt nicht von Komplikationen, sondern von ** versteckten Funktionen und dunklen Ecken von C ++ / STL **
Bilder
20
Das Programm hier gibt eine andere Ausgabe als das Original aus, da x hier nach printf dekrementiert wird. Das zeigt gut, wie "einfache Antworten" normalerweise falsch sind.
Öö Tiib
2
The OP's way: 9 8 7 6 5 4 3 2 1 0undThe Garry_G way: 10 9 8 7 6 5 4 3 2 1
Anthony
2
Es macht nicht das Gleiche. Bewegen Sie Ihre x=x-1vorher, printfdann können Sie sagen "es macht das gleiche".
CITBL
26

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.

Zohaib Ejaz
quelle
5
Das ist falsch. Der Code in der Frage lautet: 'test-write-execute' (zuerst testen, neuen Wert schreiben, Schleife ausführen), Ihr Beispiel ist 'test-execute-write'.
v010dya
@ v010dya Die Antwort wurde korrigiert, jetzt ist es test-write-executewie in der Frage, danke für den Hinweis!
Kotauskas
@VladislavToncharov Deine Bearbeitung war immer noch falsch. Siehe meine.
SS Anne
8

(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

  1. Sie können verwenden
(\
  \
   x --> 0)

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

  1. Sie können verwenden
(\
  \
   x --> 0
          \
           \
            )

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

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

Kalana
quelle