C/C++ Keywords

A keyword is an identifier to which the compiler assigns a formal meaning during tokenisation, such that the identifier is in general reserved for the compiler’s interpretation of the language and is not usable for naming code or data.

Note however that this generality has two broad exceptions. One is provided by the preprocessor: a keyword can be redefined by a macro and thus hidden from the compiler. Another exception is provided by the compiler itself: a keyword can be referred to explicitly as an identifier by giving it as an argument to __identifier (though some need enclosure in double-quotes).

Conditions

Some identifiers become keywords only in some conditions. Many depend on command-line options (most notably /clr, /noBool, /ZB, /Zc:wchar_t and /Ze). Some are keywords in C++ but not in C. Where the table below lists no condition, the identifier is recognised as a keyword by both the C and C++ compilers in all circumstances.

Of the command-line options that affect the list of keywords, -ZE and -Zf are not known to CL.EXE but can be passed to the front-end compiler modules indirectly, via the /d1 option. The term “managed build” is shorthand for any of the C1XX options -Gil, -Gmanaged or -Goptil, the first of which is an ordinary outcome of giving CL the /clr option.

Tokenisation

Though keywords are C/C++ identifiers when examined as text, they do not tokenise as identifiers. See, for instance, that

#pragma message rubbish                 // C4083
#pragma message void                    // C4081

produces two different warnings, the first to complain about the identifier rubbish, the second just about (the token) void.

Among the several hundred types of token recognised by the compiler are many that are dedicated to keywords and operators. Tokenisation maps each keyword to one of these dedicated tokens. Multiple keywords can map to the same token.

The text of a keyword is for all practical purposes lost during tokenisation. Error and warning messages that cite the token show the standard text for that token, which may differ from the text that actually produced the token. For instance, the warning produced by

#pragma message __alignof               // C4081

complains about finding something called __builtin_alignof. Similarly, where a keyword is given as input to __identifier for conversion back to an identifier, the text given for the keyword is long gone and the name produced for the identifier is the standard name of the keyword as a token. For instance, in the function declaration

int __identifier (__alignof) (void *);  // C4932 if /Ze 

the name given to the function is __builtin_alignof. Moreover, the warning, C4932, at level 4 and not raised at all if compiled with /Za, speaks only of confusion over whether __builtin_alignof has one or two leading underscores.

For each keyword, the table below shows the standard text of the corresponding token, if this differs from the text of the keyword.

Disabled Keywords

Many identifiers that are defined as keywords are disabled, as a special case of keyword tokenisation. Every disabled keyword maps to the one token, just for disabled keywords, which gets discarded from the token stream after showing a warning (C4226, C4233, C4234, C4235 or C4236). For instance, in

#pragma message __huge rubbish          // C4226 and C4083

retrieval of the disabled-keyword token that represents the text __huge produces warning C4226, after which __huge may as well have been white space.

Master List of C/C++ Keywords

With keywords acting essentially as reserved words in the language, a master list is surely helpful. In the table below of keywords recognised by Microsoft Visual C++ version 13.00.9466, those that are omitted from the product documentation’s list of C++ Keywords are highlighted yellow. They are not all undocumented: they are just not included in what the documentation seems to present as its master list. Some are mentioned elsewhere in the product documentation, even as keywords. Some are disabled, mostly as being obsolete or unsupported (in this product). All nonetheless are keywords and “cannot be used as identifiers in your program” any more than can the identifiers that Microsoft does happen to list as keywords.

The product documentation lists __m64, __m128, __m128d, __m128i and __noop as keywords. They may be significant to the compiler, and in interesting ways, but they are not actually implemented as keywords and they are therefore not listed as keywords in these notes.