O que é o operador "->" em C ++?

Depois de ler características ocultas e Dark Corners de C ++ / STL on comp.lang.c++.moderated, I foi completamente surpreso que o seguinte trecho compilado e trabalhou em ambos os Visual Studio 2008 e G ++ 4.4.

Aqui está o código:

#include <stdio.h>
int main()
{
    int x = 10;
    while (x --> 0) // x goes to 0
    {
        printf("%d ", x);
    }
}

Resultado:

9 8 7 6 5 4 3 2 1 0

Eu diria que este é C, pois também funciona no GCC. De onde isso é definido no padrão e de onde veio?

-->não é um operador. Na verdade, são dois operadores separados, --e >.

O código da condicional diminui x, enquanto retorna xo valor original (não diminuído) e, em seguida, compara o valor original com o 0uso do >operador.

Para entender melhor, a declaração pode ser escrita da seguinte maneira:

while( (x--) > 0 )

Ou para algo completamente diferente ... xdesliza para 0.

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

Não é tão matemático, mas ... toda imagem pinta mil palavras ...

Esse é um operador muito complicado, portanto, mesmo o ISO / IEC JTC1 (Comitê Técnico Conjunto 1) colocou sua descrição em duas partes diferentes do Padrão C ++.

Brincadeiras à parte, eles são dois operadores diferentes: --e >descritos respectivamente nos §5.2.6 / 2 e §5.9 da Norma C ++ 03.

É equivalente a

while (x-- > 0)

x--(pós-decremento) é equivalente a x = x-1, o código se transforma em:

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

x pode ir para zero ainda mais rápido na direção oposta:

int x = 10;

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

8 6 4 2

Você pode controlar a velocidade com uma flecha!

int x = 100;

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

90 80 70 60 50 40 30 20 10

;)

Está

#include <stdio.h>
int main(void){
     int x = 10;

     while( x-- > 0 ){ // x goes to 0

       printf("%d ", x);
     }

     return 0;
}

Apenas o espaço faz as coisas parecerem engraçadas, --diminui e >compara.

O uso de -->tem relevância histórica. Decrementar foi (e ainda é, em alguns casos), mais rápido que incrementar na arquitetura x86. Usar -->sugere que isso xvai 0e apela para aqueles com formação matemática.

while( x-- > 0 )

é assim que é analisado.

Totalmente nerd, mas vou usar isso:

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

Um livro que li (não me lembro corretamente de qual livro) declarou: Os compiladores tentam analisar expressões para o maior token usando a regra esquerda direita.

Nesse caso, a expressão:

x-->0

Analisa os maiores tokens:

token 1: x
token 2: --
token 3: >
token 4: 0
conclude: x-- > 0

A mesma regra se aplica a esta expressão:

a-----b

Após a análise:

token 1: a
token 2: --
token 3: --
token 4: -
token 5: b
conclude: (a--)-- - b

Espero que isso ajude a entender a expressão complicada ^^

É exatamente o mesmo que

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

para números não negativos

De qualquer forma, temos um operador "vai para" agora. "-->"é fácil ser lembrado como uma direção, e "enquanto x chega a zero" tem sentido direto.

Além disso, é um pouco mais eficiente do que "for (x = 10; x > 0; x --)"em algumas plataformas.

Esse código primeiro compara x e 0 e depois diminui x. (Também foi dito na primeira resposta: você está decrescendo x e depois comparando x e 0 com o >operador.) Veja a saída deste código:

9 8 7 6 5 4 3 2 1 0

Agora, primeiro comparamos e depois diminuímos vendo 0 na saída.

Se quisermos primeiro diminuir e depois 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;
}

Essa saída é:

9 8 7 6 5 4 3 2 1

Meu compilador imprimirá 9876543210 quando eu executar esse código.

#include <iostream>
int main()
{
    int x = 10;

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

Como esperado. O que while( x-- > 0 )realmente significa while( x > 0). A x--postagem diminui x.

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

é uma maneira diferente de escrever a mesma coisa.

É bom que o original pareça "enquanto x vai para 0".

Falta um espaço entre --e >. xé pós-decrementado, ou seja, diminuído após a verificação da condição x>0 ?.

--é o operador de decremento e >é o operador maior que .

Os dois operadores são aplicados como um único -->.

É uma combinação de dois operadores. Primeiro, --é para diminuir o valor e >verificar se o valor é maior que o operando do lado direito.

#include<stdio.h>

int main()
{
    int x = 10;

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

    return 0;
}

A saída será:

9 8 7 6 5 4 3 2 1 0            

Na verdade, xé pós-decrementar e com essa condição está sendo verificada. Não é -->, é(x--) > 0

Nota: o valor de xé alterado após a condição ser verificada, porque é pós-decrescente. Alguns casos semelhantes também podem ocorrer, por exemplo:

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

C e C ++ obedecem à regra "máxima mastigação". Da mesma forma que a --- b é traduzido para (a--) - b, no seu caso, é x-->0traduzido para (x--)>0.

O que a regra diz essencialmente é que, da esquerda para a direita, as expressões são formadas usando o máximo de caracteres que formarão uma expressão válida.

Por que toda a complicação?

A resposta simples para a pergunta original é apenas:

#include <stdio.h>
int main()
{
    int x = 10;
    while (x > 0) 
    {
        printf("%d ", x);
        x = x-1;
    }
}

Faz a mesma coisa. Não estou dizendo que você deve fazer assim, mas faz a mesma coisa e teria respondido à pergunta em um post.

O x--é apenas uma abreviação para o acima exposto e >é apenas um normal maior que operator. Nenhum grande mistério!

Há muita gente complicando as coisas simples hoje em dia;)

Da maneira convencional, definiríamos uma condição entre whileparênteses do loop ()e uma condição de terminação dentro dos chavetas {}, mas -->definem as duas ao mesmo tempo.

Por exemplo:

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

Isso diminui ae executa o loop enquanto aé maior que 0.

Convencionalmente, seria como:

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

Nos dois sentidos, fazemos a mesma coisa e alcançamos os mesmos objetivos.

(x --> 0) significa (x-- > 0)

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

2. você pode usar (-- x > 0) é mau(--x > 0)
output -: 9 8 7 6 5 4 3 2 1

3. você pode usar

(--\
    \
     x > 0)

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

4. você pode usar

(\
  \
   x --> 0)

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

5. você pode usar

(\
  \
   x --> 0
          \
           \
            )

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

6. você pode usar também

(
 x 
  --> 
      0
       )

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

Da mesma forma, você pode tentar vários métodos para executar este comando com sucesso