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

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

   

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) 

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

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

Brincadeiras à parte, são dois operadores diferentes: -- e > descritos respectivamente em §5.2.6 / 2 e §5.9 do C ++ 03 Standard.

É equivalente a

 while (x-- > 0) 

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

😉

Está

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

 while( x-- > 0 ) 

é como isso é analisado.

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

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

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

Há um espaço faltando entre -- e > . x é pós-decrementado, isto é, decrementado depois de verificar a condição x>0 ? .

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

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

É uma combinação de dois operadores. Primeiro -- é para decrementar o valor e > é para verificar se o valor é maior que o operando à direita.

 #include 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-decremento e com essa condição está sendo verificada. Não é --> , é (x--) > 0

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

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

C e C ++ obedecem à regra “maximum munch”. Da mesma forma que a — b é traduzida para (a--) - b , no seu caso x-->0 traduz em (x--)>0 .

O que a regra diz essencialmente é que da esquerda para a direita, as expressões são formadas tomando 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  int main() { int x = 10; while (x > 0) { printf("%d ", x); x = x-1; } } 

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

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

Há muita gente fazendo coisas simples complicadas hoje em dia;)

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

Se você fosse escrever a function para fazer o contrário, a syntax é muito mais óbvia, não é preciso dizer que eu acho que não a tinha visto antes:

  #include  int main() { int x {10}; while (x ++< 20) // x increments to 20 { printf("%d ", x); } } 

Resultado:

11 12 13 14 15 16 17 18 19 20