Qu'est-ce que l'opérateur "->" en C ++?
Après avoir lu Fonctionnalités cachées et Dark Corners de C++/STL sur comp.lang.c++.moderated, j'ai été complètement surpris que l'extrait suivant ait été compilé et utilisé 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, puisque cela fonctionne aussi dans GCC. Où est-ce 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 de la condition décrémente x, en renvoyant la valeur d'origine (non décrémentée) de x, puis compare la valeur d'origine à 0 à l'aide de l'opérateur >.
Pour mieux comprendre, l'énoncé pourrait être écrit comme suit:
while( (x--) > 0 )
Ou pour quelque chose de complètement différent ... x diapositives à 0
while (x --\
\
\
\
> 0)
printf("%d ", x);
Pas si mathématique que ça, mais ... chaque image vaut mille mots ...
C'est un opérateur très compliqué, donc même ISO/IEC 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 équivalent à
while (x-- > 0)
x-- (post décrément) est équivalent à x = x-1 donc, le code se transforme en:
while(x > 0) {
x = x-1;
// logic
}
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;
}
Juste l'espace rend les choses drôles, -- décrémente et > compare.
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 sur 0, et plaira à ceux qui ont des connaissances en mathématiques.
while( x-- > 0 )
voici comment cela est analysé.
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 avec le 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 ^^
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 un opérateur "va à" maintenant. "-->" est facile à retenir comme une direction, et "tant que x passe à zéro" signifie tout simplement.
De plus, il est un peu plus efficace que "for (x = 10; x > 0; x --)" sur certaines plates-formes.
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 le résultat de ce code:
9 8 7 6 5 4 3 2 1 0
Nous comparons maintenant, 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 réalité while( x > 0). Le post 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".
Il manque un espace entre -- et >. x est post décrémenté, c'est-à-dire après vérification de la condition x>0 ?.
-- est l'opérateur décrément 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. D'abord, -- sert à décrémenter la valeur, et > sert à 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é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 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
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 plus grand que operator. Pas de grand mystère!
Il y a trop de gens qui compliquent les choses simples de nos jours;)
De manière classique, nous définirions une condition dans la parenthèse while de la boucle () et une condition de terminaison à l'intérieur des accolades {}, mais --> définit les deux à la fois.
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 alors que a est supérieur à 0.
Classiquement, ce serait comme:
int abc(void)
{
int a = 5;
while(a > 0)
{
a--;
// Code
}
a--;
}
Dans les deux cas, nous faisons la même chose et atteignons les mêmes objectifs.