logicos - operadores relacionales en c++




¿Qué es el operador “->” en C++? (14)

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?

https://code.i-harness.com


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


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

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.


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


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


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

;)







standards-compliance