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

Après avoir lu les fonctions cachées et coins sombres de C ++ / STL sur comp.lang.c++.moderated, j'ai été complètement surpris que le suivant extrait compilé et a travaillé 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);
    }
}

Production:

9 8 7 6 5 4 3 2 1 0

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

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

Le code du conditionnel diminue x, tout en renvoyant xla valeur d'origine (non décrémentée) de, puis compare la valeur d'origine avec l' 0utilisation de l' >opérateur.

Pour mieux comprendre, la déclaration pourrait être rédigée comme suit:

while( (x--) > 0 )

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

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

Pas si 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 au §5.2.6 / 2 et au §5.9 de la norme C ++ 03.

C'est équivalent à

while (x-- > 0)

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

while(x > 0) {
    x = x-1;
    // logic
}
x--;   // The post decrement done when x <= 0

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

;)

Ses

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

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

       printf("%d ", x);
     }

     return 0;
}

L'espace juste rend les choses drôles, --diminue et >compare.

L'utilisation de -->a une pertinence historique. La décrémentation était (et l'est toujours dans certains cas), plus rapide que l'incrémentation sur l'architecture x86. L'utilisation -->suggère que cela xva 0et fait appel à ceux qui ont des antécédents mathématiques.

while( x-- > 0 )

est comment c'est analysé.

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 du livre) a déclaré: Les compilateurs essaient d'analyser les expressions sur le plus gros jeton en utilisant la règle de 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 ^^

C'est exactement la même chose que

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

pour les nombres non négatifs

Quoi qu'il en soit, nous avons maintenant un opérateur "va à". "-->"est facile à retenir comme une direction, et "tandis que x va à zéro" est un sens direct.

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 comparez ensuite 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 puis décrémentons 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 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 fait while( x > 0). Le x--poste diminue x.

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

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

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

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

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

C'est une combinaison de deux opérateurs. La première --consiste à 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            

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

Remarque: la valeur de xest modifiée après la 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éissent à la règle du "grignotage maximal". De la même manière que a --- b est traduit en (a--) - b, dans votre cas, se x-->0traduit par (x--)>0.

Ce que la règle dit essentiellement, c'est que, 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 d'origine est juste:

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

Fait la même chose. Je ne dis pas que vous devriez le faire comme ça, mais cela fait la même chose et aurait répondu à la question dans un message.

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

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

De la manière conventionnelle, nous définirions une condition dans la whileparenthèse de boucle ()et une condition de terminaison à l'intérieur des accolades {}, mais--> définir les deux à la fois.

Par exemple:

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

Cela décrémente aet exécute la boucle tandis que aest supérieur à0 .

Classiquement, ce serait:

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.

(x --> 0) veux dire (x-- > 0)

1. vous pouvez utiliser (x -->)
output -: 9 8 7 6 5 4 3 2 1 0

2. vous pouvez utiliser (-- x > 0) c'est méchant(--x > 0)
output -: 9 8 7 6 5 4 3 2 1

3. vous pouvez utiliser

(--\
    \
     x > 0)

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

4. vous pouvez utiliser

(\
  \
   x --> 0)

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

5. vous pouvez utiliser

(\
  \
   x --> 0
          \
           \
            )

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

6. vous pouvez également utiliser

(
 x 
  --> 
      0
       )

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

de même, vous pouvez essayer de nombreuses méthodes pour exécuter cette commande avec succès