Por que a +++++ b não funciona?

int main ()
{
   int a = 5,b = 2;
   printf("%d",a+++++b);
   return 0;
}

Este código fornece o seguinte erro:

erro: lvalue necessário como operando de incremento

Mas se eu colocar espaços em toda a extensão a++ +e ++b, funcionará bem.

int main ()
{
   int a = 5,b = 2;
   printf("%d",a++ + ++b);
   return 0;
}

O que o erro significa no primeiro exemplo?

printf("%d",a+++++b);é interpretado como de (a++)++ + bacordo com a Regra Munch Máxima ^! .

++(postfix) não avalia como um, lvaluemas requer que seu operando seja um lvalue.

_{! 6.4 / 4 diz que o próximo token de pré-processamento é a mais longa sequência de caracteres que poderia constituir um token de pré-processamento "}

Os compiladores são escritos em etapas. O primeiro estágio é chamado de lexer e transforma os personagens em uma estrutura simbólica. Portanto, "++" se torna algo como um enum SYMBOL_PLUSPLUS. Posteriormente, o estágio do analisador transforma isso em uma árvore de sintaxe abstrata, mas não pode alterar os símbolos. Você pode afetar o lexer inserindo espaços (que terminam com os símbolos, a menos que estejam entre aspas).

Os lexers normais são gananciosos (com algumas exceções), então seu código está sendo interpretado como

a++ ++ +b

A entrada para o analisador é um fluxo de símbolos, então seu código seria algo como:

[ SYMBOL_NAME(name = "a"), 
  SYMBOL_PLUS_PLUS, 
  SYMBOL_PLUS_PLUS, 
  SYMBOL_PLUS, 
  SYMBOL_NAME(name = "b") 
]

Que o analisador considera sintaticamente incorreto. (EDITAR com base em comentários: Semanticamente incorreto porque você não pode aplicar ++ a um valor r, no qual um ++ resulta)

a+++b 

é

a++ +b

O que está ok. Assim como seus outros exemplos.

O lexer usa o que geralmente é chamado de algoritmo de "mastigação máxima" para criar tokens. Isso significa que, à medida que está lendo os caracteres, ele continua lendo os caracteres até encontrar algo que não pode ser parte do mesmo token que já possui (por exemplo, se estiver lendo dígitos, então o que tem é um número, se encontrar an A, ele sabe que não pode ser parte do número. então ele para e deixa o Ano buffer de entrada para usar como o início do próximo token). Em seguida, ele retorna esse token para o analisador.

Nesse caso, isso significa que +++++é lexed como a ++ ++ + b. Como o primeiro pós-incremento produz um rvalue, o segundo não pode ser aplicado a ele e o compilador fornece um erro.

Apenas FWIW, em C ++ você pode sobrecarregar operator++para gerar um lvalue, o que permite que isso funcione. Por exemplo:

struct bad_code { 
    bad_code &operator++(int) { 
        return *this;
    }
    int operator+(bad_code const &other) { 
        return 1;
    }
};

int main() { 
    bad_code a, b;

    int c = a+++++b;
    return 0;
}

Compila e executa (embora não faça nada) com os compiladores C ++ que tenho à mão (VC ++, g ++, Comeau).

Este exemplo exato é coberto no esboço da norma C99 ( mesmos detalhes em C11 ) seção 6.4 Elementos lexicais, parágrafo 4, que diz:

Se o fluxo de entrada foi analisado em tokens de pré-processamento até um determinado caractere, o próximo token de pré-processamento é a mais longa sequência de caracteres que poderia constituir um token de pré-processamento. [...]

que também é conhecida como regra de mastigação máxima, usada na análise lexical para evitar ambigüidades e funciona pegando o máximo de elementos possível para formar um token válido.

o parágrafo também tem dois exemplos, o segundo é uma correspondência exata para sua pergunta e é o seguinte:

EXEMPLO 2 O fragmento de programa x +++++ y é analisado como x ++ ++ + y, o que viola uma restrição nos operadores de incremento, embora a análise x ++ + ++ y possa produzir uma expressão correta.

que nos diz que:

a+++++b

será analisado como:

a ++ ++ + b

que viola as restrições do incremento posterior, uma vez que o resultado do primeiro incremento posterior é um rvalue e o incremento posterior requer um lvalue. Isso é abordado na seção 6.5.2.4 Operadores de incremento e decremento do Postfix que diz ( ênfase minha ):

O operando do operador de incremento ou decremento postfix deve ter o tipo real ou ponteiro qualificado ou não qualificado e deve ser um lvalue modificável.

e

O resultado do operador postfix ++ é o valor do operando.

O livro C ++ Gotchas também cobre este caso em Gotcha #17 Maximal Munch Problems . É o mesmo problema em C ++ e também dá alguns exemplos. Isso explica ao lidar com o seguinte conjunto de caracteres:

->*

o analisador léxico pode fazer uma das três coisas:

• Tratá-lo como três fichas: -, >e*
• Trate-o como dois tokens: ->e*
• Trate-o como um token: ->*

A regra da mastigação máxima permite evitar essas ambigüidades. O autor aponta que ( no contexto C ++ ):

resolve muito mais problemas do que causa, mas em duas situações comuns, é um incômodo.

O primeiro exemplo seriam modelos cujos argumentos de modelo também são modelos (o que foi resolvido em C ++ 11 ), por exemplo:

list<vector<string>> lovos; // error!
                  ^^

Que interpreta os colchetes angulares de fechamento como o operador de deslocamento e, portanto, um espaço é necessário para desambiguar:

list< vector<string> > lovos;
                    ^

O segundo caso envolve argumentos padrão para ponteiros, por exemplo:

void process( const char *= 0 ); // error!
                         ^^

seria interpretado como *=operador de atribuição, a solução neste caso é nomear os parâmetros na declaração.

Seu compilador tenta desesperadamente analisar a+++++be interpretar como (a++)++ +b. Agora, o resultado do pós-incremento ( a++) não é um lvalue , ou seja, não pode ser pós-incrementado novamente.

Nunca escreva esse código em programas de qualidade de produção. Pense no pobre sujeito que está vindo atrás de você e que precisa interpretar seu código.

(a++)++ +b

a ++ retorna o valor anterior, um rvalue. Você não pode incrementar isso.

Porque causa comportamento indefinido.

Qual é?

c = (a++)++ + b
c = (a) + ++(++b)
c = (a++) + (++b)

Sim, nem você nem o compilador sabem disso.

EDITAR:

O verdadeiro motivo é o dito pelos outros:

É interpretado como (a++)++ + b.

mas o incremento posterior requer um lvalue (que é uma variável com um nome), mas (a ++) retorna um rvalue que não pode ser incrementado, levando à mensagem de erro que você recebe.

Obrigado aos outros por apontar isso.

Acho que o compilador vê isso como

c = ((a ++) ++) + b

++deve ter como operando um valor que pode ser modificado. a é um valor que pode ser modificado. a++no entanto, é um 'rvalue', não pode ser modificado.

Pela forma como o erro que eu ver em GCC C é o mesmo, mas de forma diferente redigida: lvalue required as increment operand.

Siga esta ordem de precessão

1. ++ (pré-incremento)

2. + - (adição ou subtração)

3. "x" + "y" adiciona a sequência

int a = 5,b = 2; printf("%d",a++ + ++b); //a is 5 since it is post increment b is 3 pre increment return 0; //it is 5+3=8