opérateur - symbole en c++

Faites attention

--> n'est pas un opérateur. Il s’agit en fait de deux opérateurs distincts -- et > .

Le code de la condition décrémente x , tout en renvoyant la valeur d'origine de x (non décrémentée), puis compare la valeur d'origine à 0 à l'aide de l'opérateur > .

Pour mieux comprendre, la déclaration pourrait être écrite comme suit:

while((x--) > 0)

C'est équivalent à

while (x-- > 0)

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

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

C'est un opérateur très compliqué, c'est pourquoi même l' ISO / CEI JTC1 (Comité technique mixte 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 une combinaison de deux opérateurs. First -- sert à décrémenter la valeur, et > à 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            

De manière conventionnelle, nous définissons la condition entre parenthèses dans la boucle while " () " et la condition de terminaison à l'intérieur des accolades " {} ", mais ceci -- & > est un moyen de définir tout à la fois. Par exemple:

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

Il dit: décrémentez a et exécutez la boucle jusqu'à ce a soit supérieur à 0

Autrement, cela aurait dû être comme:

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

Dans les deux cas, nous faisons la même chose et atteignons les mêmes objectifs.

En fait, x est post-décrémenté et avec cette condition est en cours de vérification. Ce n'est pas --> , c'est (x--) > 0

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

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

L'utilisation 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. Utiliser --> suggère que x va à 0 et plaira à ceux qui ont des connaissances en mathématiques.

Mon compilateur imprimera 9876543210 lorsque 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 réalité while( x > 0) . Le poste x-- décrémente x .

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

est une manière différente d’écrire la même chose.

C'est bien que l'original ressemble à "pendant que x passe à 0".

Pourquoi toute la complication?

La réponse simple à la question initiale est simplement:

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

Fait la même chose. Ne dites pas que vous devriez le faire comme ça, mais il fait la même chose et aurait répondu à la question en un post.

Le x-- est juste un raccourci pour ce qui précède, et > est juste un operator normal supérieur à. Pas de grand mystère!

Il y a trop de gens qui compliquent les choses simples de nos jours;)

Quoi qu'il en soit, nous avons un opérateur "va à" maintenant. "-->" est facile à retenir comme direction, et "tant que x va à zéro" signifie tout simplement.

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

Tout à fait 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 rappelle plus exactement quel livre) a déclaré: Les compilateurs essaient d'analyser les expressions du plus gros jeton en utilisant la règle gauche-droite.

Dans ce cas, l'expression:

x-->0

Analyse les plus gros 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

Après analyse:

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

-- est l'opérateur de décrémentation et > est l'opérateur supérieur à .

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

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

;)