c++ - jerarquia - operadores logicos en lenguaje c
¿Qué es el operador “->” en C++? (21)
Después de leer las funciones ocultas y las esquinas oscuras de C ++ / STL en comp.lang.c++.moderated , me sorprendió completamente que el siguiente fragmento de código compilado y trabajado tanto en Visual Studio 2008 como en G ++ 4.4.
Aquí está el código:
#include <stdio.h>
int main()
{
int x = 10;
while (x --> 0) // x goes to 0
{
printf("%d ", x);
}
}
Supongo que esto es C, ya que también funciona en GCC. ¿Dónde se define esto en la norma y de dónde viene?
Presta atención
-->No es un operador. De hecho, son dos operadores separados,--y>.
El código del condicional disminuye x , mientras devuelve el valor original de x (no decrementado), y luego compara el valor original con 0 usando el operador > .
Para comprender mejor, la declaración se podría escribir de la siguiente manera:
while((x--) > 0)
¿Por qué toda la complicación?
La respuesta simple a la pregunta original es simplemente:
#include <stdio.h>
int main()
{
int x = 10;
while (x > 0)
{
printf("%d ", x);
x = x-1;
}
}
Hace lo mismo. No digo que debas hacerlo así, pero hace lo mismo y habría respondido la pregunta en una publicación.
La x-- es solo una forma abreviada de lo anterior, y > es simplemente un operator mayor que el normal. No hay gran misterio!
Hay demasiada gente haciendo cosas simples complicadas hoy en día;)
De todos modos, tenemos un operador "va a" ahora. "-->" es fácil de recordar como una dirección, y "mientras que x va a cero" tiene sentido.
Además, es un poco más eficiente que "for (x = 10; x > 0; x --)" en algunas plataformas.
El uso de --> tiene relevancia histórica. La disminución fue (y sigue siendo en algunos casos), más rápida que el incremento en la arquitectura x86. Usar --> sugiere que x va a 0 , y apela a aquellos con antecedentes matemáticos.
En realidad, x es posterior al decremento y con esa condición se está comprobando. No es --> , es (x--) > 0
Nota: el valor de x se cambia después de que se verifique la condición, ya que se produce una disminución posterior. También pueden ocurrir algunos casos similares, por ejemplo:
--> x-->0
++> x++>0
-->= x-->=0
++>= x++>=0
En un libro que leí (no recuerdo correctamente qué libro) decía: Los compiladores intentan analizar las expresiones con el token más grande usando la regla izquierda-derecha.
En este caso, la expresión:
x-->0
Analiza los tokens más grandes:
token 1: x
token 2: --
token 3: >
token 4: 0
conclude: x-- > 0
La misma regla se aplica a esta expresión:
a-----b
Después de analizar
token 1: a
token 2: --
token 3: --
token 4: -
token 5: b
conclude: (a--)-- - b
Espero que esto ayude a entender la expresión complicada ^^
Es equivalente a
while (x-- > 0)
x-- (decremento posterior) es equivalente a x = x-1 , por lo que el código se transforma en:
while(x > 0) {
x = x-1;
// logic
}
Es un operador muy complicado, por lo que incluso ISO / IEC JTC1 (Comité Técnico Conjunto 1) colocó su descripción en dos partes diferentes de la Norma C ++.
Bromas aparte, son dos operadores diferentes: -- y > descritos respectivamente en §5.2 / 2 y §5.9 de la Norma C ++ 03.
Es una combinación de dos operadores. Primero -- es para disminuir el valor, y > es para verificar si el valor es mayor que el operando de la derecha.
#include<stdio.h>
int main()
{
int x = 10;
while (x-- > 0)
printf("%d ",x);
return 0;
}
La salida será:
9 8 7 6 5 4 3 2 1 0
Este código primero compara x y 0 y luego disminuye x. (También se dice en la primera respuesta: estás reduciendo x y luego comparando x y 0 con el operador > ). Mira la salida de este código:
9 8 7 6 5 4 3 2 1 0
Ahora primero comparamos y luego decrementamos viendo 0 en la salida.
Si queremos primero disminuir y luego comparar, use este código:
#include <stdio.h>
int main(void)
{
int x = 10;
while( --x> 0 ) // x goes to 0
{
printf("%d ", x);
}
return 0;
}
Esa salida es:
9 8 7 6 5 4 3 2 1
Esto es exactamente lo mismo que
while (x--)
{
printf("%d ", x);
}
para números no negativos
Falta un espacio entre -- y > . x Se decrementa la publicación x , es decir, se disminuye después de verificar la condición x>0 ? .
La forma convencional definimos la condición en el paréntesis de bucle while " () " y la condición de terminación dentro de las llaves " {} ", pero esta -- & > es una forma en que uno define todo a la vez. Por ejemplo:
int abc(){
int a = 5
while((a--) > 0){ // Decrement and comparison both at once
// Code
}
}
Dice, decrementa a y ejecuta el bucle hasta que el tiempo a sea mayor que 0
De otra manera debería haber sido como:
int abc(){
int a = 5
while(a > 0){
// Code
a = a -1 // Decrement inside loop
}
}
En ambos sentidos, hacemos lo mismo y logramos los mismos objetivos.
Mi compilador imprimirá 9876543210 cuando ejecute este código.
#include <iostream>
int main()
{
int x = 10;
while( x --> 0 ) // x goes to 0
{
std::cout << x;
}
}
Como se esperaba. El while( x-- > 0 ) realidad significa while( x > 0) . La publicación x-- decrementa x .
while( x > 0 )
{
x--;
std::cout << x;
}
Es una forma diferente de escribir lo mismo.
Es bueno que el original se vea como "mientras que x va a 0".
O para algo completamente diferente ... x diapositivas a 0
while (x --/
/
/
/
> 0)
printf("%d ", x);
No es tan matemático, pero ... cada imagen vale más que mil palabras ...
Sus
#include <stdio.h>
int main(void){
int x = 10;
while( x-- > 0 ){ // x goes to 0
printf("%d ", x);
}
return 0;
}
Solo el espacio hace que las cosas se vean divertidas, -- decrementa y > compara.
Totalmente geek, pero usaré esto:
#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;
}
-- es el operador de disminución y > es el operador mayor que .
Los dos operadores se aplican como uno solo como --> .
x puede ir a cero incluso más rápido en la dirección opuesta:
int x = 10;
while( 0 <---- x )
{
printf("%d ", x);
}
8 6 4 2
¡Puedes controlar la velocidad con una flecha!
int x = 100;
while( 0 <-------------------- x )
{
printf("%d ", x);
}
90 80 70 60 50 40 30 20 10
;)
while( x-- > 0 )
Es así como se analiza.