.. _lang-keywords: Keywords ======== This page lists all of the C++ keywords, and either links to a reference page explaining their use, or provides a brief description. List of Keywords ---------------- The C++ keywords are: ``and``, ``and_eq``, ``asm``, ``auto``, ``bitand``, ``bitor``, ``bool``, ``break``, ``case``, ``catch``, ``char``, ``class``, ``compl``, ``const``, ``const_cast``, ``continue``, ``default``, ``delete``, ``do``, ``double``, ``dynamic_cast``, ``else``, ``enum``, ``explicit``, ``export``, ``extern``, ``false``, ``float``, ``for``, ``friend``, ``goto``, ``if``, ``inline``, ``int``, ``long``, ``mutable``, ``namespace``, ``new``, ``not``, ``not_eq``, ``operator``, ``or``, ``or_eq``, ``private``, ``protected``, ``public``, ``register``, ``reinterpret_cast``, ``return``, ``short``, ``signed``, ``sizeof``, ``static``, ``static_cast``, ``struct``, ``switch``, ``template``, ``this``, ``throw``, ``true``, ``try``, ``typedef``, ``typeid``, ``typename``, ``union``, ``unsigned``, ``using``, ``virtual``, ``void``, ``volatile``, ``wchar_t``, ``while``, ``xor``, ``xor_eq`` Boolean Operator Synonyms ------------------------- - ``and`` is a synonym for :ref:`&& <lang-boolean-and>`. - ``not`` is a synonym for :ref:`\! <lang-boolean-not>`. - ``not_eq`` is a synonym for :ref:`\!= <lang-comparison>`. - ``or`` is a synonym for :ref:`|| <lang-boolean-or>`. Bitwise Operator Synonyms ------------------------- - ``and_eq`` is a synonym for :ref:`&= <lang-compoundbitwise-and>`. - ``bitand`` is a synonym for (bitwise) :ref:`& <lang-bitwisemath-and>`. - ``bitor`` is a synonym for :ref:`\| <lang-bitwisemath-or>`. - ``compl`` is a synonym for :ref:`~ <lang-bitwisemath-not>`. - ``or_eq`` is a synonym for :ref:`|= <lang-compoundbitwise-or>`. - ``xor`` is a synonym for :ref:`^ <lang-bitwisemath-xor>`. - ``xor_eq`` is a synonym for :ref:`^= <lang-compoundbitwise-xor>`. Constants --------- - ``true`` and ``false`` are the :ref:`boolean constants <lang-booleanvariables>`. Control Flow ------------ - ``break`` can exit out of a :ref:`switch statement <lang-switchcase>` or a :ref:`for <lang-for>`, :ref:`do <lang-dowhile>`, or :ref:`while <lang-while>` loop. - ``case`` defines alternatives in a :ref:`switch statement <lang-switchcase>`. - ``continue`` will move control flow to the next iteration of the enclosing :ref:`for <lang-for>`, :ref:`do <lang-dowhile>`, or :ref:`while <lang-while>` loop. - ``default`` defines the default alternative in a :ref:`switch statement <lang-switchcase>`. - ``do`` introduces a :ref:`do <lang-dowhile>` loop. - ``else`` is used in :ref:`if statements <lang-if>`. - ``for`` introduces a :ref:`for <lang-for>` loop. - ``goto`` :ref:`jumps <lang-goto>` to a label. - ``if`` introduces an :ref:`if statement <lang-if>`. - ``return`` :ref:`transfers flow to a function's caller <lang-return>`. - ``switch`` introduces a :ref:`switch statement <lang-switchcase>`. - ``while`` introduces a :ref:`while <lang-while>` loop. Types ----- The following keywords are used for built-in types. - :ref:`bool <lang-booleanvariables>` - :ref:`char <lang-char>` - :ref:`double <lang-double>` - :ref:`float <lang-float>` - :ref:`int <lang-int>` - :ref:`long <lang-long>` - :ref:`short <lang-built-in-types-integral>` - :ref:`void <lang-void>` (not really a type, but used in the absence of one) The following keywords are used to introduce new types. - :ref:`enum <lang-enum>` Qualifiers ---------- - :ref:`static <lang-static>` can be used to declare persistent local variables; it has other uses not documented here. - ``unsigned`` is used to specify an unsigned integral type. Examples: :ref:`lang-unsignedint`, :ref:`lang-unsignedchar`. - :ref:`volatile <lang-volatile>` is useful when declaring variables that may be modified by external interrupts. - :ref:`const <lang-const>` is used to define constants. Other ----- These keywords are not described in the Maple documentation. For more information, consult a C++ reference. - ``asm`` is used to insert literal assembly language. - ``auto`` is used to declare that a variable has automatic storage. - ``catch`` is used in exception handling. Note that the default flags we pass to :ref:`GCC <arm-gcc>` include ``-fno-exceptions``. - ``class`` is used to define classes. - ``const_cast`` is used in typecasting. - ``delete`` is used to free ``new``\ -allocated storage. Note that dynamic memory allocation is not available by default on the Maple, so you'll have to bring your own ``new`` and ``delete`` if you want this. - ``dynamic_cast`` is used in typecasting. - ``explicit`` is used to declare constructors that can be called only explicitly. - ``export`` declares a template definition accessible to other compilation units. - ``extern`` can mark a declaration as a declaration and not a definition, and also grant external linkage to a ``const`` or ``typedef``. - ``friend`` is used to declare that certain functions have access to a class's private variables. - ``inline`` is a compiler hint to inline a function. - ``mutable`` specifies that a member can be updated, even when a member of a ``const`` object. - ``namespace`` declares a new namespace. - ``new`` dynamically allocates space for a value. Note that dynamic memory allocation is not available by default on the Maple, so you'll have to bring your own ``new`` and ``delete`` if you want this. - ``operator`` is used to define type-specific operator overrides. - ``private`` declares a private class member. - ``protected`` declares a protected class member. - ``public`` declares a public class member. - ``register`` is a compiler hint to store a variable in a register. - ``reinterpret_cast`` is used in typecasting. - ``signed`` is the opposite of ``unsigned``. - ``static_cast`` is used in typecasting. - ``struct`` declares a new struct. - ``template`` introduces a template class, function, etc. - ``this`` is a pointer to the receiver object. - ``throw`` is used in exception handling. Note that the default flags we pass to :ref:`GCC <arm-gcc>` include ``-fno-exceptions``. - ``try`` is used in exception handling. Note that the default flags we pass to :ref:`GCC <arm-gcc>` include ``-fno-exceptions``. - ``typedef`` defines a type synonym. - ``union`` defines an untagged union. - ``using`` is a directive related to namespaces. - ``virtual`` declares a method which may be overridden. - ``wchar_t`` is the wide character type.