operators operadores - ¿Qué es el operador “->” en C++?




logicos relacionales (18)

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?


Answers

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.


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.


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.


C y C++ obedecen la regla de "munch máximo". De la misma manera que a --- b se traduce a (a--) - b , en su caso, x-->0 traduce a (x--)>0 .

Lo que la regla dice esencialmente es que, de izquierda a derecha, las expresiones se forman tomando el máximo de caracteres que formarán una expresión válida.


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


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
}

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


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.


while( x-- > 0 )

Es así como se analiza.


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;
}

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


¿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;)


-- es el operador de disminución y > es el operador mayor que .

Los dos operadores se aplican como uno solo como --> .


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)

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

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

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.


Las 2 primeras respuestas mencionadas == significa igualdad y === identidad. Desafortunadamente, esta afirmación es incorrecta.

Si ambos operandos de == son objetos, se comparan para ver si son el mismo objeto. Si ambos operandos apuntan al mismo objeto, entonces el operador igual devuelve verdadero. De lo contrario, los dos no son iguales.

var a = [1, 2, 3];  
var b = [1, 2, 3];  
console.log(a == b)  // false  
console.log(a === b) // false  

En el código anterior, tanto == como === se vuelven falsos porque a y b no son los mismos objetos.

Es decir: si ambos operandos de == son objetos, == se comporta igual que ===, lo que también significa identidad. La diferencia esencial de estos dos operadores es sobre la conversión de tipo. == tiene conversión antes de verificar la igualdad, pero === no lo hace.







c++ operators code-formatting standards-compliance