Qu'est-ce que l'opérateur "-- > " en C++?

ou pour quelque chose de complètement différent... x glisse à 0

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

Non mathématique, mais... chaque image vaut mille mots. ...

c'est un opérateur très compliqué, donc même ISO/IEC JTC1 (Joint Technical Committee 1) a placé sa description dans deux parties différentes de la norme C++.

blague à part, ce sont deux opérateurs différents: -- et > décrits respectivement aux §5.2.6/2 et §5.9 de la norme C++03.

c'est l'équivalent de

while (x-- > 0)

x-- (décrément postal) est équivalent à x = x-1 donc, le code se transforme en:

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

x peut aller à zéro encore plus vite dans la direction opposée:

int x = 10;

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

8 6 4 2

vous pouvez contrôler la vitesse avec une flèche!

int x = 100;

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

90 80 70 60 50 40 30 20 10

;)

Il est

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

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

       printf("%d ", x);
     }

     return 0;
}

l'espace de rendre les choses de l'air bizarre, -- décrémente et > compare.

l'usage de --> a une pertinence historique. La décrémentation était (et est encore dans certains cas), plus rapide que l'incrémentation sur l'architecture x86. L'utilisation de --> suggère que x va à 0 , et fait appel à ceux qui ont une formation mathématique.

while( x-- > 0 )

, c'est comme ça qu'on dit.

complètement geek, mais je vais utiliser ceci:

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

un livre que j'ai Lu (Je ne me souviens pas correctement quel livre) a déclaré: compilateurs essayer de parser des expressions pour le plus grand jeton en utilisant la règle de droite de gauche.

dans ce cas, l'expression:

x-->0

Analyse de plus de jetons:

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

la même règle s'applique à cette expression:

a-----b

D'après parse:

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

j'espère que cela aide à comprendre l'expression compliquée ^ ^

c'est exactement la même chose que

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

pour les numéros non négatifs

quoi qu'il en soit, nous avons un opérateur" goes to " maintenant. "-->" est facile à retenir comme une direction, et" alors que x va à zéro " signifie-Droit.

de plus, il est un peu plus efficace que "for (x = 10; x > 0; x --)" sur certaines plateformes.

ce code compare d'abord x et 0 puis décrémente X. (Également dit dans la première réponse: vous Post-décrémentez x et puis comparer x et 0 avec l'opérateur > .) Voir la sortie de ce code:

9 8 7 6 5 4 3 2 1 0

nous comparons maintenant d'abord et ensuite décroissent en voyant 0 dans la sortie.

si nous voulons d'abord décrémenter puis comparer, utilisez ce code:

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

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

cette sortie est:

9 8 7 6 5 4 3 2 1

mon compilateur imprimera 9876543210 quand j'exécuterai ce code.

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

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

comme prévu. Le while( x-- > 0 ) signifie en fait while( x > 0) . Le x-- post décrémente x .

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

est une autre façon d'écrire la même chose.

C'est beau que l'original ressemble à "tandis que x va de 0" si.

il manque un espace entre -- et > . x est décrémenté après vérification de la condition x>0 ? .

-- est le décrément opérateur et > est le plus grand-que opérateur.

les deux opérateurs sont appliqués en un seul comme --> .

C'est une combinaison de deux opérateurs. D'abord -- pour décrémenter la valeur, et > pour vérifier si la valeur est supérieure à l'opérande de droite.

#include<stdio.h>

int main()
{
    int x = 10;

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

    return 0;
}

la sortie sera:

9 8 7 6 5 4 3 2 1 0            

en fait, x est post-décrémentant et avec cette condition est vérifiée. Ce n'est pas --> , c'est (x--) > 0

Note: la valeur de x est modifiée après vérification de la condition, car elle post-décrémente. Certains cas similaires peuvent également se produire, par exemple:

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

C et C++ obéir "au maximum munch" la règle. De la même façon que a---b est traduit par (a--) - b , dans votre cas x-->0 se traduit par (x--)>0 .

ce que la règle dit essentiellement, c'est qu'en allant de gauche à droite, les expressions sont formées en prenant le maximum de caractères qui formeront une expression valide.

pourquoi toutes ces complications?

la réponse simple à la question initiale est juste:

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

Fait la même chose. Ne dis pas que vous devriez faire comme cela, mais il fait la même chose et aurait répondu à la question dans un post.

le x-- est juste un raccourci pour ce qui précède, et > est juste un plus grand normal-que operator . Pas de grand mystère!

il y a trop beaucoup de gens faire des choses simples compliquées de nos jours ;)

façon conventionnelle nous définissons la condition dans tandis que la parenthèse de boucle " () "et la condition finale à l'intérieur des accolades" {} ", mais cette -- & > est une façon que l'on définit tout à la fois. For E. g:

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

il est dit, décrément a et exécuter la boucle jusqu'à ce que le temps a est plus grand que 0

D'une autre façon, il aurait dû être comme:

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

les deux moyens, nous faisons la même chose et les mêmes objectifs.