opérateur - symbole en c++
Qu'est-ce que l'opérateur “->” en C++? (14)
Après avoir lu les caractéristiques cachées et les coins sombres de C ++ / STL sur comp.lang.c++.moderated
, Je suis complètement surpris que l'extrait suivant ait été 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, puisque cela fonctionne aussi dans GCC. Où est-ce défini dans la norme et d'où vient-il?
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
;)