Search

1.4c — Keywords and naming identifiers

Keywords

C++ reserves a set of 84 words (as of C++14) for its own use. These words are called keywords (or reserved words), and each of these keywords has a special meaning within the C++ language.

Here is a list of all the C++ keywords (through C++14):

alignas **
alignof **
and
and_eq
asm
auto
bitand
bitor
bool *
break
case
catch
char
char16_t **
char32_t **
class
compl
const
constexpr **
const_cast *
continue
decltype**
default
delete
do
double
dynamic_cast *
else
enum
explicit *
export *
extern
false *
float
for
friend
goto
if
inline
int
long
mutable *
namespace *
new
noexcept **
not
not_eq
nullptr **
operator
or
or_eq
private
protected
public
register
reinterpret_cast *
return
short
signed
sizeof
static
static_assert **
static_cast *
struct
switch
template
this
thread_local **
throw
true *
try
typedef
typeid *
typename *
union
unsigned
using *
virtual
void
volatile
wchar_t *
while
xor
xor_eq

* These 15 keywords were added in C++98. Some older reference books or material may omit these.
** These 10 keywords were added in C++11. If your compiler is not C++11 compliant, these keywords may not be functional.

C++11 also adds two special identifiers: override and final. These have a specific meaning when used in certain contexts.

You have already run across some of these keywords, including int, void, and return. Along with a set of operators, these keywords and special identifiers define the entire language of C++ (preprocessor commands excluded). Because these keywords and special identifiers have special meaning, your IDEs will change the text color of these words (usually to blue) to make them more visible.

By the time you are done with this tutorial series, you will understand what almost all of these words do!

Identifier naming rules

The name of a variable, function, type, or other kind of object in C++ is called an identifier. C++ gives you a lot of flexibility to name identifiers as you wish. However, there are a few rules that must be followed when naming identifiers:

  • The identifier can not be a keyword. Keywords are reserved.
  • The identifier can only be composed of letters (lower or upper case), numbers, and the underscore character. That means the name can not contain symbols (except the underscore) nor whitespace (spaces or tabs).
  • The identifier must begin with a letter (lower or upper case) or an underscore. It can not start with a number.
  • C++ distinguishes between lower and upper case letters. nvalue is different than nValue is different than NVALUE.

Now that you know how you can name a variable, let’s talk about how you should name a variable or function.

First, it is a convention in C++ that variable names should begin with a lowercase letter. If the variable name is one word, the whole thing should be written in lowercase letters.

Generally, functions are also started with a lowercase letter (though there’s some disagreement on this point). We’ll start ours with lower case letters for consistency, since main() (which all programs must have) starts with a lowercase letter, as do all of the functions in the C++ standard library.

Identifier names that start with a capital letter are typically used for structs, classes, and enumerations (all of which we will cover later).

If the variable or function name is multi-word, there are two common conventions: separated by underscores, or intercapped (sometimes called CamelCase, since the capital letters stick up like the humps on a camel).

In this tutorial, we will typically use the intercapped approach because it’s easier to read (it’s easy to mistake an underscore for a space in dense blocks of code). But it’s common to see either -- the C++ standard library uses the underscore method for both variables and functions. Sometimes you’ll see a mix of the two: underscores used for variables and intercaps used for functions.

It’s worth noting that if you’re working in someone else’s code, it’s generally considered better to match the style of the code you are working in than to rigidly follow the naming conventions laid out above.

Second, you should avoid naming your identifiers starting with an underscore, as these names are typically reserved for OS, library, and/or compiler use.

Third, and this is perhaps the most important rule of all, give your identifiers names that actually describe what they are. It is typical for inexperienced programmers to make variable names as short as possible, either to save on typing or because they figure the meaning is obvious. This is almost always a mistake. Ideally, variables should be named in a way that would help someone who has no idea what your code does be able to figure it out as quickly as possible. In 3 months, when you look at your program again, you’ll have forgotten how it works, and you’ll thank yourself for picking variable names that make sense. The more complex the code the variable is being used in, the better name it should have.

int ccount Bad Nobody knows what a ccount is
int customerCount Good Clear what we’re counting
int i Bad* Generally bad unless use is trivial or temporary, such as loop variables
int index Either Okay if obvious what we’re indexing
int totalScore Good Descriptive
int _count Bad Do not start variable names with underscore
int count Either Okay if obvious what we’re counting
int data Bad What kind of data?
int value1, value2 Either Can be hard to differentiate between the two
int numberOfApples Good Descriptive
int monstersKilled Good Descriptive
int x, y Bad* Generally bad unless use is trivial, such as in trivial mathematical functions

* Note: it is okay to use trivial variable names for variables that have a trivial use, such as loop variables, or trivial mathematical functions.

Fourth, a clarifying comment can go a long way. For example, say we’ve declared a variable named numberOfChars that is supposed to store the number of characters in a piece of text. Does the text “Hello World!” have 10, 11, or 12 characters? It depends on whether we’re including whitespace or punctuation. Rather than naming the variable numberOfCharsIncludingWhitespaceAndPunctuation, which is rather lengthy, a well placed comment on the declaration line should help the user figure it out:

Quiz

Pick which variables are improperly named according to standard conventions (ie. how you should name a variable) and indicate why.

1) int sum;
2) int _apples;
3) int VALUE;
4) int my variable name;
5) int TotalCustomers;
6) int void;
7) int numFruit;
8) int 3some;
9) int meters_of_pipe;

Show Solution

1.4d -- A first look at local scope
Index
1.4b -- Why functions are useful, and how to use them effectively

131 comments to 1.4c — Keywords and naming identifiers

  • vbot

    Hi Alex,

    I got used to (years of AS3 / JavaScript coding) adding a double underscore as a prefix to local variable names inside functions in order to keep them clearly separated from the global ones. When I look at the code inside one of my functions searching for global variables, my eye / brain just skips the ones beginning with a double underscore. This way I can quickly distinguish between global and local variables without having to actually read them. Other thing I like about this approach is that I don't need any editor-text-decorations like italic fonts or colors to "mark" them.

    Question: How critical would it be (for me) to still use double underscores for local variable names inside function-scope in C++ and why exactly?

    Thanks!

    • Hi vbot!

      Quoting the standard N4762 ยง 5.10 (3.1)
      "Each identifier that contains a double underscore __ or begins with an underscore followed by an uppercase letter is reserved to the implementation for any use."
      Your code might work with your compiler, but it might not work with another compiler because you're using a reserved identifier.
      In C++ prefixes like
      "g_" (global)
      "m_" (member)
      "k_" (constant)
      "s_" (static)
      are common when naming variables.

      Local variables (and parameters) don't have special prefixes.

      • vbot

        Hi nascardriver,

        thanks for the fast reply! Ok, maybe then I should better drop this habbit, it was rather confusing to other programers anyway. ๐Ÿ˜‰

        DEBUG: my exampleFunction above has to be void! ๐Ÿ˜‰

  • MrStark

    In quiz, why second variable name is wrong, while a name can begin with either lowercase letter or underscore?

    • The quiz isn't about what you _can_ do, but about what you _should_ do.
      In my opinion this shouldn't be part of this tutorial, since there are many naming conventions which are equally good.

      • MrStark

        I brought this topic because in naming rules you have stated that an identifier must start with lower case letter or underscore but you contradict it in you quiz as improper and not according to standards. Either the rules for naming identifier in your articles are wrong or the quiz. (Not personal preference but according to standards)

Leave a Comment

Put all code inside code tags: [code]your code here[/code]