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

Question

Après avoir lu les fonctionnalités cachées et les coins sombres de C ++ / STL sur comp.lang.c ++. modéré , j'ai été complètement surpris que l'extrait suivant compilé et utilisé à la fois dans Visual Studio 2008 et G ++ 4.4.

Voici le code:

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

Je suppose que c'est C, car cela fonctionne également dans GCC. Où est-ce défini dans la norme et d'où vient-il?

Answer 1

- > 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 (non décrémentée) de x , puis compare la valeur d'origine à 0 . en utilisant l'opérateur > .

Pour mieux comprendre, l'énoncé pourrait être rédigé comme suit:

while( (x--) > 0 )

Answer 2

Ou pour quelque chose de complètement différent ... x glisse vers 0

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

Pas si mathématique que ça, mais ... chaque image vaut mille mots ...

Answer 3

C'est un opérateur très compliqué, donc même 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. .

Answer 4

Cela équivaut à

while (x-- > 0)

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

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

Answer 5

x peut aller à zéro encore plus vite dans le sens opposé:

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

;)

Answer 6

C'est

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

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

       printf("%d ", x);
     }

     return 0;
}

Simplement l'espace rend les choses drôles, - décrémente et > se compare.

Answer 7

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. L'utilisation de - > suggère que x va sur 0 , et plaira à ceux qui ont une formation mathématique.

Answer 8

while( x-- > 0 )

est comment cela est analysé.

Answer 9

Tout à fait geek, mais j'utiliserai 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;
}

Answer 10

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

Answer 11

C’est exactement la même chose que

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

pour les nombres non négatifs

Answer 12

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

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

Answer 13

Ce code compare d'abord x et 0, puis décrémente x. (Également indiqué dans la première réponse: vous post-décrémentez x, puis vous comparez x et 0 à l'opérateur > .) Voir la sortie de ce code:

9 8 7 6 5 4 3 2 1 0

Nous comparons d’abord et décrémentons en voyant 0 dans la sortie.

Si nous voulons commencer par 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;
}

Ce résultat est:

9 8 7 6 5 4 3 2 1

Answer 14

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é tant que (x > 0) . Le message x - décrémente x .

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

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

Il est agréable que l'original ressemble à "pendant que x passe à 0". bien que.

Answer 15

Il manque un espace entre - et > . x est post décrémenté, c'est-à-dire après la vérification de la condition x > 0? .

Answer 16

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

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

Answer 17

C'est une combinaison de deux opérateurs. Le premier - 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;
}

Le résultat sera:

9 8 7 6 5 4 3 2 1 0            

Answer 18

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 une fois la condition vérifiée, car elle post-décrémente. Certains cas similaires peuvent également se produire, par exemple:

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

Answer 19

C et C ++ obéir à la règle" Consommation maximale ". règle. De la même manière, a --- b est traduit en (a--) - b , dans votre cas, x - > 0 est traduit en (x- -) > 0 .

En gros, la règle dit que, de gauche à droite, les expressions sont formées en prenant le maximum de caractères qui formeront une expression valide.

Answer 20

Pourquoi toute cette 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 simplement un raccourci pour ce qui précède, et > est simplement un opérateur normal supérieur à . Pas de grand mystère!

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

Answer 21

De manière classique, nous définirions une condition dans la parenthèse de la boucle while () et une condition de fin entre les accolades {} , mais - > définit les deux en même temps.

Par exemple:

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

Ceci décrémente a et exécute la boucle tandis que un est supérieur à 0 .

Classiquement, ce serait comme:

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

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