utilizados - ou-> c++




Qual é o operador “->” em C++? (14)

Preste atenção

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

O código da condicional decrementa x , enquanto retorna o valor original de x (não decrementado), e então compara o valor original com 0 usando o operador > .

Para entender melhor, a declaração poderia ser escrita da seguinte forma:

while((x--) > 0)

Depois de ler Hidden Features e Dark Corners de C ++ / STL em comp.lang.c++.moderated , fiquei completamente surpreso com o seguinte trecho compilado e trabalhado no Visual Studio 2008 e no 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);
    }
}

Eu suponho que isso é C, já que funciona no GCC também. Onde isso é definido no padrão e de onde vem?


É equivalente a

while (x-- > 0)

x-- (post decrement) é equivalente a x = x-1 , então o código se transforma em:

while(x > 0) {
    x = x-1;
    // logic
}

De maneira convencional, definimos condição no parêntese while do laço " () " e condição de terminação dentro das chaves " {} ", mas essa -- & > é uma forma que se define de uma só vez. Por exemplo:

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

Diz, decrementa ae executa o loop até o tempo a é maior que 0

De outra forma, deveria ter sido assim:

int abc(){
    int a = 5
    while(a > 0){
        // Code
        a = a -1 // Decrement inside loop
    }
}

nos dois sentidos, fazemos o mesmo e atingimos os mesmos objetivos.


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

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


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.


Este código compara primeiro xe 0 e depois decrementa x. (Também disse na primeira resposta: Você está pós-decrementando x e então 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 decrementar e 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

Isso é exatamente o mesmo que

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

para números não negativos


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 while( x-- > 0 ) while( x > 0) na verdade significa while( x > 0) . O x pós decrementa x .

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

é uma maneira diferente de escrever a mesma coisa.

É legal que o original pareça "while x vai para 0".


O uso de --> tem relevância histórica. Decrementar era (e ainda é, em alguns casos) mais rápido que incrementar na arquitetura x86. Usando --> sugere que x está indo para 0 e apela para aqueles com histórico matemático.


Ou para algo completamente diferente ... x slides para 0

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

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


Totalmente geek, mas eu vou estar usando 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 eu li (não me lembro corretamente de qual livro) afirmou: Os compiladores tentam analisar expressões para o maior símbolo usando a regra da esquerda à direita.

Neste 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 aplica-se a esta expressão:

a-----b

Após 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 ^^


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

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


x pode ir a 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

;)





standards-compliance