Before we start with the more interesting parts of C++ programming, I’d like to share some information about “identifiers” in C and C++.
As the name suggests, an identifier identifies something. This can be the declaration of a variable, a data type, a function or anything else that is allowed as part of a program source code.
In a computer program, an identifier is a keyword that identifies different operations or data descriptions within the given computer programming language.
In order to be valid, an identifier has to start with a letter. After that, it can contain a sequence of letters, digits or underscore characters. Blank space characters, punctuation marks and symbols are not allowed for identifiers.
The letters you use for an identifier can be small or capital letters. It is important to remember though that C++ is a “case sensitive” programming language.
This means that similar identifiers with a different combination of small and capital letters do not refer to the same object. If you name a variable “MYVAR” when it is defined and use “myVar” later in order to access its contents, the compiler tell you that “myVar” is an “undeclared identifier”.
Modern code editors and integrated development environments keep track of your identifiers and help you to use the right letters by often providing a pop-up list with the already existing identifiers from your code.
While you can use underscore characters (“_”) at the beginning of an identifier, you should not do that for your own identifiers.
Single or double underscore characters are usually used for special compiler-related or external identifiers. If you define an identifier that matches a compiler-identifier (which usually passes special instructions to the compiler), this can have unforeseen side effects, and the program may not work the way you intend it to.
If you look at the programs from the earlier parts of this tutorial, you can find a lot of identifiers in their code.
Like most other programming languages, C++ uses certain identifiers as so called “reserved keywords”. These keywords are used for the syntax of the programming language, and can only be used in the way that is allowed by the syntax rules of the language. You cannot use these keywords as identifiers for your own variables, data types, functions etc.
You will get to know the meaning and usage of most reserved keywords during the upcoming parts of this tutorial (some were already used in earlier programs), but for now here is a list of the reserved keywords for C++ in alphabetical order that you can use as a reference:
| Keyword of bits |
Keyword type | Meaning |
|---|---|---|
| alignas | declaration | specifies the alignment requirement of a type or an object |
| alignof | definition | queries alignment requirements of a type |
| and | operator | Boolean (logical) “AND” operation between two expressions or values |
| and_eq | operator | alternative operator for “&=”, bit-wise “AND” operation for a value or expression (e.g. binary values “1100” and “0111” combined with “and_eq” will result in the binary value “0100” as the second bit is set to “1” and equal to the Boolean “true” value in both binary values, while the rest is “false” when each position of the value is compared) |
| asm | declaration | declaration of an inline assembly block (used to add assembler code inside C and C++ code) |
| auto | declaration | the type of a variable will be determined from the initialization of that variable (i.e. from the type of value that it is assigned) |
| bitand | operator | bit-by-bit logical “AND” operation between two expressions or values (similar to “and_eq”) |
| bitor | operator | bit-by-bit logical “OR” operation between two expressions or value |
| bool | declaration | defines a variable of the type “boolean” that can only have the values “true” or “false” |
| break | control structure | stop end exit a currently running loop or command block inside a program, returning to the code outside the loop or command block |
| case | control structure | declaration of the case labels for a switch statement |
| catch | control structure | part of a try-catch block of commands, declaring the expression to be catched |
| char | declaration | declares a character type variable |
| char16_t | declaration | declaration of a character type variable using 16 bits |
| char32_t | declaration | declaration of a character type variable using 32 bits |
| class | declaration | declaration of an object class |
| compl | operator | alternative operator for ~ |
| const | specifier | declaration of a constant |
| constexpr | declaration | specifies that the value of a variable or function can appear in constant expressions> |
| const_cast | declaration | type conversion expression, declares an expression as constant |
| continue | control structure | causes the remaining portion of the enclosing loop body to be skipped, continue the program starting from the beginning of the loop with the next loop counter value |
| decltype | declaration | declare the data type of a variable depending on the type of a given expression |
| default | control structure | declare a specific case in a switch statement as the default option to be executed when no other cases are met |
| delete | operator | invokes an object destructor that deletes the object instance and releases the previously reserved memory (that was allocated with the “new” expression) |
| do | control structure | declares the start of a do-while loop |
| double | declaration | declares a double precision floating point type |
| dynamic_cast | declaration | safely converts pointers and references to classes up, down, and sideways along the inheritance hierarchy |
| else | control structure | declares the start of the second option part in an if-else control structure |
| enum | declaration | declares an enumeration type |
| explicit | declaration | specifies constructors and conversion operators that don't allow implicit conversions or copy-initialization |
| export | declaration | before the C++11 standard this used to mark a template definition to be exported, which allows the same template to be declared, but not defined, in other translation units |
| extern | declaration | defines a storage class as extern, with static or thread storage duration and external linkage |
| false | literal | boolean literal for the "false" boolean value |
| final | specifier | specifies that a virtual function cannot be overridden in a derived class or that a class cannot be inherited from |
| float | declaration | declares a variable or value to be of floating point type (can be single precision) |
| for | control structure | marks the start of a "for"-loop |
| friend | declaration | used for methods or attributes of an object class definition in order to make specific private or protected methods or attributes available for another object class or function |
| goto | control structure | unconditional branch to a different part of the same function or method marked by the referenced label |
| if | control structure | start of a conditional branch structure that is executed when the following condition is true |
| inline | declaration | definition of an inline function or namespace |
| int | declaration | defines a variable or value of the type integer |
| long | declaration | defines a variable or value of the type long integer for bigger integer values |
| mutable | specifier | defines a class member as non-static, specifies that the member does not affect the externally visible state of the class |
| namespace | declaration | declares a namespace for object methods and attributes from external libraries that are used in a program |
| new | operator | creates a new instance of an object class and reserves the necessary memory |
| noexcept | operator | performs a compile-time check that returns true if an expression is declared to not throw any exceptions |
| not | operator | Boolean operator for negating a Boolean expression |
| not_eq | operator | Boolean operator for “NOT EQUAL” |
| nullptr | declaration | declaration of a “null” pointer |
| operator | declaration | declaration of an overloaded operator |
| or | operator | Boolean “OR” operator |
| or_eq | operator | alternative Boolean operator for “OR EQUAL” |
| override | specifier | specifies that a virtual function overrides another virtual function |
| private | declaration | private access specifier for parts of an object class definition |
| protected | declaration | protected access specifier for parts of object classes |
| public | declaration | public access specifier for parts of object classes |
| register | declaration | automatic storage duration specifier |
| reinterpret_cast | declaration | defines a type conversion expression that does not compile to any CPU instructions |
| return | declaration | declares the return statement of a program, function or method |
| short | declaration | declaration of a “short” integer type variable |
| signed | declaration | declares a numeric variable to be signed (uses first bit to show if the value is positive or negative), so zero, positive and negative values are permitted |
| sizeof | operator | returns the memory size of a given type, expression or object |
| static | declaration | declares the storage duration of a variable or class member as static |
| static_assert | operator | performs compile-time assertion checking |
| static_cast | operator | converts between types using a combination of implicit and user-defined conversions |
| struct | declaration | definition of a custom data structure (made up of one or more variables of similar or different types or classes) |
| switch | control structure | declaration of a switch statement |
| template | declaration | declaration of a template |
| this | operator | ”this” pointer (pointer to current object instance) |
| thread_local | declaration | thread storage duration specifier |
| throw | control structure | signals an erroneous condition and executes an error handler |
| true | literal | literal for Boolean “true” value |
| try | control structure | start of a try-catch block; associates one or more exception handlers (catch-clauses) with a compound statement |
| typedef | declaration | used for user-defined data types |
| typeid | operator | queries information of a type |
| typename | declaration | definition of type template parameters, template template parameters or dependent names as a type |
| union | declaration | declaration of a union data type |
| unsigned | declaration | defines a numeric data type as unsigned, so only zero and positive values are permitted |
| using | declaration | references a type, namespace or function- or method-definition that is defined outside of the current declarative region (e.g. in a separate file or library) |
| virtual | declaration | specifies that a non-static member function or a base class is virtual and supports dynamic binding |
| void | declaration | declares a function or method return value or pointer to have no defined type, turning functions into procedures |
| volatile | specifier | defines a variable type to be volatile – every access of a volatile object is handled in a separate thread |
| wchar_t | declaration | definition of a character type for wide character representation |
| while | control structure | start of a while loop that is executed as long as the Boolean control expression returns true |
| xor | operator | Boolean “exclusive OR” operator |
| xor_eq | operator | Boolean “exclusive OR EQUAL” operator |
Specific compilers may also have additional specific reserved keywords, but the above list shows all reserved standard C++ keywords up until the C++11 standard.
You can use the table above as a reference if you do not write your code in a specialized code editor.
Specialized code editors – either separate ones like “Notepad++” or IDE-integrated editors (like in the “Qt Creator” IDE) usually have integrated support for C++ and other programming languages. If you use a specialized code editor, you can use the automatic code completion and syntax highlighting to see which words are reserved keywords.
What happens when you use C++ identifiers or reserved keywords as names for your own variables, types, functions etc.?
Doing this automatically leads to errors in your program – not only syntax errors which are easy to fix, but also logical errors that can be difficult to locate and fix.
So my recommendation is to use a dedicated code editor that supports the programming language you use (C++ in case of this tutorial). Identifiers and reserved keywords will be offered for auto-completion when you are typing in your code, and they will be highlighted in different colors and styles, making it easy to spot them in your code.
That should be enough for now. I hope you’ll join me in the next part of the C++ with Qt tutorial when things get a little more interesting…