¿Cuál es el operador "->" en C ++?

Después de leer las características ocultas y oscuras esquinas de C ++ / STL sobre comp.lang.c++.moderated, me sorprendió por completo que el siguiente fragmento compila y se trabajó tanto en Visual Studio 2008 y 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);
    }
}

Salida:

9 8 7 6 5 4 3 2 1 0

Supongo que esto es C, ya que también funciona en GCC. ¿Dónde se define esto en el estándar y de dónde viene?

-->No es un operador. De hecho, son dos operadores separados, --y >.

El código del condicional disminuye x, mientras devuelve xel valor original (no disminuido) y luego compara el valor original con el 0uso del >operador.

Para comprender mejor, la declaración podría escribirse de la siguiente manera:

while( (x--) > 0 )

O para algo completamente diferente ... se xdesliza a 0.

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

No es tan matemático, pero ... cada imagen vale más que mil palabras ...

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 del Estándar C ++.

Bromas aparte, son dos operadores diferentes: --y se >describen respectivamente en §5.2.6 / 2 y §5.9 del Estándar C ++ 03.

Es equivalente a

while (x-- > 0)

x--(disminución posterior) es equivalente a x = x-1esto, el código se transforma en:

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

x puede ir a cero aún 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

;)

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, --decrecientes y >comparables.

El uso de -->tiene relevancia histórica. Disminuir fue (y sigue siendo en algunos casos), más rápido que incrementar en la arquitectura x86. El uso -->sugiere que eso xva a ser 0y atrae a aquellos con antecedentes matemáticos.

while( x-- > 0 )

es cómo se analiza eso.

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

Un libro que leí (no recuerdo correctamente qué libro) decía: Los compiladores intentan analizar las expresiones al token más grande usando la regla izquierda derecha.

En este caso, la expresión:

x-->0

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

Esto es exactamente lo mismo que

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

para números no negativos

De todos modos, tenemos un operador "va a" ahora. "-->"es fácil de recordar como una dirección, y "mientras x va a cero" tiene sentido directo.

Además, es un poco más eficiente que "for (x = 10; x > 0; x --)"en algunas plataformas.

Este código primero compara xy 0 y luego disminuye x. (También se dice en la primera respuesta: estás decrementando 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 disminuimos al ver 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

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 )realmente significa while( x > 0). Los x--decretos posteriores x.

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

Es una forma diferente de escribir lo mismo.

Sin embargo, es bueno que el original se vea como "mientras x va a 0".

Falta un espacio entre --y >. xes posterior decrementado, es decir, decrementado después de verificar la condición x>0 ?.

--es el operador de decremento y >es el operador mayor que .

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

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

El resultado será:

9 8 7 6 5 4 3 2 1 0            

En realidad, xestá disminuyendo posteriormente y con esa condición se está comprobando. No es -->, es(x--) > 0

Nota: el valor de xse cambia después de que se verifica la condición, porque se reduce posteriormente. Algunos casos similares también pueden ocurrir, por ejemplo:

-->    x-->0
++>    x++>0
-->=   x-->=0
++>=   x++>=0

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

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

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

El x--es solo una abreviatura de lo anterior, y >es solo un normal mayor que operator. No hay gran misterio!

Hay demasiada gente haciendo las cosas simples complicadas hoy en día;)

De la manera convencional, definiríamos una condición en el whileparéntesis del bucle ()y una condición de terminación dentro de los corchetes {}, pero -->define ambos a la vez.

Por ejemplo:

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

Esto disminuye ay ejecuta el ciclo mientras aes mayor que 0.

Convencionalmente, sería como:

int abc(void)
{
    int a = 5;
    while(a > 0)
    {
        a--;
        // Code
    }
    a--;
}

En ambos sentidos, hacemos lo mismo y alcanzamos los mismos objetivos.

(x --> 0) medio (x-- > 0)

1. puedes usar (x -->)
output -: 9 8 7 6 5 4 3 2 1 0

2. puedes usar (-- x > 0) Es malo(--x > 0)
output -: 9 8 7 6 5 4 3 2 1

3. puedes usar

(--\
    \
     x > 0)

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

4. puedes usar

(\
  \
   x --> 0)

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

5. puedes usar

(\
  \
   x --> 0
          \
           \
            )

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

6. puedes usar también

(
 x 
  --> 
      0
       )

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

Del mismo modo, puede probar muchos métodos para ejecutar este comando con éxito