Perché a +++++ b non funziona?

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

Questo codice restituisce il seguente errore:

errore: lvalore richiesto come operando di incremento

Ma se inserisco spazi ovunque a++ +e ++b, allora funziona bene.

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

Cosa significa l'errore nel primo esempio?

printf("%d",a+++++b);è interpretato come (a++)++ + bsecondo la regola di Maximal Munch ^! .

++(postfix) non restituisce un lvaluema richiede che il suo operando sia un lvalue.

_{! 6.4 / 4 dice che il prossimo token di pre-elaborazione è la sequenza più lunga di caratteri che potrebbe costituire un token di pre-elaborazione "}

I compilatori vengono scritti in più fasi. La prima fase si chiama lexer e trasforma i personaggi in una struttura simbolica. Quindi "++" diventa qualcosa come un file enum SYMBOL_PLUSPLUS. Successivamente, la fase del parser lo trasforma in un albero di sintassi astratto, ma non può modificare i simboli. Puoi influenzare il lexer inserendo spazi (che terminano con i simboli a meno che non siano tra virgolette).

I lexer normali sono avidi (con alcune eccezioni), quindi il tuo codice viene interpretato come

a++ ++ +b

L'input per il parser è un flusso di simboli, quindi il tuo codice sarebbe qualcosa del tipo:

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

Che il parser pensa sia sintatticamente errato. (MODIFICA basata sui commenti: semanticamente errato perché non è possibile applicare ++ a un valore r, che risulta in a ++)

a+++b 

è

a++ +b

Che va bene. Così sono i tuoi altri esempi.

Il lexer utilizza quello che viene generalmente chiamato un algoritmo di "munch massimo" per creare token. Ciò significa che mentre sta leggendo i caratteri, continua a leggere i caratteri finché non incontra qualcosa che non può far parte dello stesso token di quello che ha già (ad esempio, se sta leggendo cifre quindi quello che ha è un numero, se incontra an A, sa che non può essere parte del numero, quindi si ferma e lascia il Anel buffer di input da utilizzare come inizio del token successivo). Quindi restituisce quel token al parser.

In questo caso, ciò significa che +++++viene lexed come a ++ ++ + b. Poiché il primo post-incremento restituisce un valore, il secondo non può essere applicato e il compilatore restituisce un errore.

Solo FWIW, in C ++ puoi eseguire l'overload operator++per produrre un lvalue, che consente a questo di funzionare. Per esempio:

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

Lo compila e funziona (anche se non fa nulla) con i compilatori C ++ che ho a portata di mano (VC ++, g ++, Comeau).

Questo esempio esatto è trattato nella bozza dello standard C99 ( stessi dettagli in C11 ) sezione 6.4 Elementi lessicali paragrafo 4 che in dice:

Se il flusso di input è stato analizzato in token di pre-elaborazione fino a un dato carattere, il token di pre-elaborazione successivo è la sequenza di caratteri più lunga che potrebbe costituire un token di pre-elaborazione. [...]

che è anche conosciuta come la regola del munch massimale che viene utilizzata nell'analisi lessicale per evitare ambiguità e funziona prendendo il maggior numero di elementi possibile per formare un segno valido.

il paragrafo ha anche due esempi il secondo è una corrispondenza esatta per la tua domanda ed è il seguente:

ESEMPIO 2 Il frammento di programma x +++++ y viene analizzato come x ++ ++ + y, che viola un vincolo sugli operatori di incremento, anche se l'analisi x ++ + ++ y potrebbe produrre un'espressione corretta.

che ci dice che:

a+++++b

sarà analizzato come:

a ++ ++ + b

che viola i vincoli sull'incremento di post poiché il risultato del primo incremento di post è un rvalue e l'incremento di post richiede un lvalue. Questo è trattato nella sezione 6.5.2.4 Operatori di incremento e decremento di Postfix che dice ( enfasi mia ):

L'operando dell'operatore di incremento o decremento postfisso deve avere un tipo reale o puntatore qualificato o non qualificato e deve essere un valore modificabile.

e

Il risultato dell'operatore postfisso ++ è il valore dell'operando.

Il libro C ++ Gotchas copre anche questo caso in Gotcha #17 Maximal Munch Problems , è lo stesso problema anche in C ++ e fornisce anche alcuni esempi. Spiega che quando si ha a che fare con il seguente set di caratteri:

->*

l'analizzatore lessicale può fare una di tre cose:

• Trattarlo come tre gettoni: -, >e*
• Trattalo come due gettoni: ->e*
• Trattalo come un token: ->*

La regola del munch massimo consente di evitare queste ambiguità. L'autore sottolinea che ( nel contesto C ++ ):

risolve molti più problemi di quanti ne provoca, ma in due situazioni comuni è un fastidio.

Il primo esempio sarebbero i modelli i cui argomenti del modello sono anche modelli ( che è stato risolto in C ++ 11 ), ad esempio:

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

Che interpreta le parentesi angolari di chiusura come l' operatore di spostamento , quindi è necessario uno spazio per disambiguare:

list< vector<string> > lovos;
                    ^

Il secondo caso riguarda argomenti predefiniti per i puntatori, ad esempio:

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

verrebbe interpretato come *=operatore di assegnazione, la soluzione in questo caso è nominare i parametri nella dichiarazione.

Il tuo compilatore cerca disperatamente di analizzarlo a+++++be lo interpreta come (a++)++ +b. Ora, il risultato di post-increment ( a++) non è un lvalue , cioè non può essere post-incrementato di nuovo.

Per favore, non scrivere mai questo codice nei programmi di qualità della produzione. Pensa al poveretto che ti viene dietro e che ha bisogno di interpretare il tuo codice.

(a++)++ +b

a ++ restituisce il valore precedente, un rvalue. Non puoi incrementarlo.

Perché provoca un comportamento indefinito.

Qual é?

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

Sì, né tu né il compilatore lo sapete.

MODIFICARE:

Il vero motivo è quello come detto dagli altri:

Viene interpretato come (a++)++ + b.

ma post increment richiede un lvalue (che è una variabile con un nome) ma (a ++) restituisce un rvalue che non può essere incrementato portando così al messaggio di errore che ottieni.

Grazie agli altri per averlo fatto notare.

Penso che il compilatore lo veda come

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

++deve avere come operando un valore modificabile. a è un valore che può essere modificato. a++tuttavia è un "valore", non può essere modificato.

Tra l'altro l'errore che vedo su GCC C è lo stesso, ma in modo diverso-formulata: lvalue required as increment operand.

Segui questo ordine di precisione

1. ++ (pre incremento)

2. + - (addizione o sottrazione)

3. "x" + "y" aggiungono entrambe le sequenze

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