Quando sono stati introdotti i token alternativi "and" e "or" in C++?

Question

L'ho appena letto bel pezzo da Reddit.

Menzionano and E or essere "Token alternativi" a && E ||

Fino ad ora ne ero davvero all'oscuro.Naturalmente tutti lo sanno di-grafi e tri-grafi, Ma and E or?Da quando?Si tratta di un'aggiunta recente allo standard?

L'ho appena controllato con Visual C++ 2008 e non sembra riconoscerli come qualcosa di diverso da un errore di sintassi.Cosa sta succedendo?

Answer 1

MSVC li supporta come parole chiave solo se si utilizza l'opzione /Za per disabilitare le estensioni; questo è vero da almeno VC7.1 (VS2003).

È possibile ottenere loro sostenuti come macro includendo iso646.h.

La mia ipotesi è che credono che le parole chiave che li rende di default sarebbe rompere troppo codice esistente (e io non sarei sorpreso se hanno ragione).

Questo è stato discusso in una domanda un paio di settimane fa, da qualche parte qui su SO, ma non riesco a ottenere così di ricerca o di Google per trovare il dannato.

Answer 2

Dalla C ++ 11 di serie, 2.6/ Alternative tokens:

1. rappresentazioni simboliche alternativi sono forniti per alcuni operatori e segni di punteggiatura.
2. Sotto tutti gli aspetti della lingua, ogni token alternativa si comporta, rispettivamente, come token primario, ad eccezione della sua ortografia. L'insieme di token alternativi è definito nella tabella 2.

Tabella 2 - gettoni alternativi

alternative primary | alternative primary | alternative primary
--------------------+---------------------+--------------------
   <%          {    |    and         &&   |    and_eq      &=
   %>          }    |    bitor       |    |    or_eq       |=
   <:          [    |    or          ||   |    xor_eq      ^=
   :>          ]    |    xor         ^    |    not         !
   %:          #    |    compl       ~    |    not_eq      !=
   %:%:        ##   |    bitand      &    |

Answer 3

Per rispondere in realtà la domanda:

Sono stati definiti nel primo standard C ++.

Answer 4

Si veda lo standard C ++. Il progetto di comitato # 2 è liberamente disponibile a ftp: //ftp.research.att com / dist / C ++ std / WP / CD2 / body.pdf , anche se è non autorevole, out-of-date, e parzialmente non corretto in alcuni punti. Specificamente, nella sezione 2.5, Gettoni alternative , vengono definiti i seguenti:

Alternative Primary
<%          {
%>          }
<:          [
:>          ]
%:          #
%:%:        ##
and         &&
bitor       |
or          ||
xor         ^
compl       ~
bitand      &
and_eq      &=
or_eq       |=
xor_eq      ^=
not         !
not_eq      !=

Anche se onestamente, non ho mai visto nessuno di loro ha mai utilizzato se non per and, or e not, e anche allora, questi sono rari. Si noti che questi non sono consentiti per impostazione predefinita in codice C pianura, solo in C ++. Se si desidera utilizzarli in C, dovrete sia #define da soli come macro, o #include il <iso646.h> intestazione, che definisce tutto quanto sopra tranne che per <% >% <: :> %: %:%: come macro (vedere paragrafo 7.9 della C99 standard).

Answer 5

Si può essere sorpresi di conoscere il resto di loro:

and and_eq bitand bitor compl not not_eq or or_eq xor xor_eq

C ++ Parole .

Credo che le versioni recenti di GCC supportano queste parole chiave.

Answer 6

Sebbene la domanda sia vecchia, vorrei fornirle una risposta più o meno completa:I token alternativi facevano già parte del C++98 attualmente ritirato (ISO/IEC 14882:1998, che, credo, fu il primo standard ISO per C++).Sebbene non sia una prova in sé (e non possiedo una copia dell'ISO per c++98), ecco un collegamento: vedere la sezione C++.

Come menzionato nelle altre risposte, il compilatore MSVC sta violando [lex.digrafo] sezione della norma quando /Za il flag non è specificato.

Answer 7

Il GNU compilatore g ++ li ha, ma non so su MS VC ++.

È possibile ottenere la stessa funzionalità mettendo questo nella parte superiore del file di codice.

#define and &&
#define bitor |
#define or ||
#define xor ^
#define compl ~
#define bitand &
#define and_eq &=
#define or_eq ^=
#define xor_eq ^=
#define not !
#define not_eq !=

Anche se questo è un pò hacker, dovrebbe funzionare.

Answer 8

Sono nel documento di lavoro per il nuovo standard C ++, a pagina 14: C ++ standard