Literals and const

Suppose you’re writing a small program and you use 0.08 as the tax rate in ten different places. Three months later, the tax rate changes. Now you have to hunt down every 0.08 and hope you don’t miss one.

This is the problem that constants solve.

Before we get to constants though, let’s understand what a literal is.

What is a literal?

A literal is a value you write directly into source code. You’ve already seen these:

Each of those values on the right (100, 0.08, 'A', true) is a literal. It’s a fixed value baked directly into your program text.

The type of a literal

Literals have types, just like variables do. C++ figures out the type from how you write the value. For example:

• 100 is an int
• 100.0 is a double
• 100.0f is a float (the f suffix makes this explicit)
• 'A' is a char
• "hello" is a string literal (we’ll cover its type properly in Chapter 7)
• true and false are bool

The f suffix tells C++ to treat the value as a float rather than a double. If you omit the suffix, C++ will create a double literal and then convert it to a float. This may result in a value being squeezed into a type that can’t represent it as precisely.

There are also integer suffixes:

Other bases

You can write integer literals in other bases too. Note that each prefix below starts with a zero (0), not the letter O:

The decimal system we use every day has ten digits: 0-9. Hexadecimal has sixteen, so after 9 it continues with A-F. Octal uses 0-7. Binary uses only 0 and 1. You’ll encounter hex most often when working with colors or low-level bit patterns.

Digit separators

C++14 also lets you use single quotes as digit separators for readability:

This makes large numbers much easier to read at a glance. The separators are purely cosmetic and the compiler completely ignores them.

The const keyword

Back to the tax rate problem. Instead of scattering a raw value like 0.08 across your code, you declare a variable once to hold it and mark it as unchangeable. This can be done using the const keyword:

The const keyword tells the compiler: this variable’s value may not change after initialization. If you modify the above code by uncommenting line 5, you’ll get a compile error. This is one of C++’s core philosophies: catch errors as early as possible.

The naming convention ALL_CAPS for constants is just a convention. C++ doesn’t enforce it. But it’s nearly universal in C++ code, and following it signals intent immediately. When a reader sees TAX_RATE, they know at a glance it’s not going to change.

Initializing a const variable

Unlike a regular variable, a const variable has to be given a value when it’s declared. This makes sense because if you can’t modify it later, where else would you set it?

Using const with other types

const works with any type:

Key takeaways

• A literal is a value written directly in source code. Its type depends on how you write it.
• const marks a variable as unchangeable after initialization. Trying to modify it is a compile error.
• The naming convention ALL_CAPS for constants is near-universal in C++.