Constants and literals in C++ - Deep Dive

Overview - Constants and literals

What is it?

Constants and literals are fixed values in a program that do not change during execution. A literal is the actual value written in the code, like the number 5 or the word "hello". A constant is a named value that is set once and cannot be changed later. They help programmers write clear and safe code by preventing accidental changes to important values.

Why it matters

Without constants and literals, programs would be harder to understand and maintain because values could change unexpectedly. This could cause bugs and make the program behave unpredictably. Constants make the code safer and easier to read by clearly showing which values should stay the same. Literals let programmers write exact values directly in the code, making it simple to use fixed data.

Where it fits

Before learning constants and literals, you should understand basic data types like integers, floats, and strings. After this, you can learn about variables, expressions, and how to use constants in functions and classes. This topic is a foundation for writing reliable and readable C++ programs.

Mental Model

Core Idea

Constants and literals are fixed values in code that never change, helping keep programs safe and clear.

Think of it like...

Think of a literal as a label stuck on a box showing exactly what's inside, and a constant as a locked box with a label that can’t be changed once sealed.

┌───────────────┐       ┌───────────────┐
│   Literal     │       │  Constant     │
│ (fixed value) │       │ (named fixed  │
│ e.g. 42, 'a'  │──────▶│  value)       │
└───────────────┘       │ e.g. const int│
                        │ PI = 3.14     │
                        └───────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding literals in C++

Concept: Introduce what literals are and how they represent fixed values in code.

Literals are the actual fixed values you write in your code. For example, 10 is an integer literal, 3.14 is a floating-point literal, and 'x' is a character literal. When you write these, the computer understands them as exact values. They are the building blocks for data in your program.

Result

You can write numbers, characters, and strings directly in your code as fixed values.

Knowing literals helps you understand how data is represented directly in your program without needing variables.

2

Foundation

Basic constants with const keyword

Concept: Learn how to create named constants using the const keyword to prevent changes.

In C++, you can create a constant by using the const keyword before a variable type. For example, const int daysInWeek = 7; means daysInWeek is a constant integer that cannot be changed later. Trying to change it will cause a compile error. This protects important values from accidental modification.

Result

You can create named values that stay the same throughout the program.

Using const makes your code safer by preventing accidental changes to important values.

3

Intermediate

Different types of literals

🤔Before reading on: do you think all literals are just numbers and text? Commit to your answer.

Concept: Explore the variety of literals in C++, including integer, floating-point, character, string, and boolean literals.

C++ supports many literal types: integer literals like 100, floating-point literals like 2.5, character literals like 'c', string literals like "hello", and boolean literals true and false. You can also write literals in different formats, like hexadecimal (0xFF) or octal (077). Each literal type tells the compiler what kind of data it is.

Result

You understand how to write and recognize different fixed values in C++ code.

Recognizing literal types helps you write correct code and understand how the compiler treats values.

4

Intermediate

Literal suffixes and type modifiers

🤔Before reading on: do you think a number literal always has the same type? Commit to your answer.

Concept: Learn how suffixes change the type of literals, like 10u for unsigned or 3.14f for float.

In C++, you can add suffixes to literals to specify their exact type. For example, 10u means an unsigned int, 10L means a long int, 3.14f means a float, and 3.14 means a double by default. This helps the compiler know exactly what type you want, which can prevent bugs and improve performance.

Result

You can control the type of literals precisely using suffixes.

Knowing suffixes prevents subtle bugs caused by type mismatches and helps optimize your program.

5

Intermediate

Using constexpr for compile-time constants

🤔Before reading on: do you think const and constexpr mean the same thing? Commit to your answer.

Concept: Introduce constexpr, which tells the compiler to compute the constant value at compile time.

constexpr is a keyword that means the value is constant and can be calculated during compilation, not at runtime. For example, constexpr int square(int x) { return x * x; } lets you create constants from functions. This can make programs faster and safer by catching errors early.

Result

You can create constants that the compiler fully knows before running the program.

Understanding constexpr unlocks powerful optimizations and safer code by moving calculations to compile time.

6

Advanced

Immutable objects and const correctness

🤔Before reading on: do you think const only applies to simple variables? Commit to your answer.

Concept: Learn how const applies to objects, pointers, and references to enforce immutability.

In C++, const can be used with pointers and references to prevent changing the data they point to. For example, const int* means the integer pointed to cannot be changed, but the pointer can. int* const means the pointer cannot change, but the data can. Using const correctly helps avoid bugs and makes interfaces clear about what can be modified.

Result

You can write code that clearly shows which data can and cannot be changed.

Mastering const correctness is key to writing robust, maintainable C++ code.

7

Expert

Literal types and user-defined literals

🤔Before reading on: do you think literals are only built-in types? Commit to your answer.

Concept: Explore how C++ allows creating custom literal suffixes for user-defined types.

C++11 introduced user-defined literals, letting you define how literals with custom suffixes behave. For example, you can write 10_km to represent 10 kilometers as a special type. This is done by defining functions with special names. It helps make code more readable and expressive, especially in domains like units or currencies.

Result

You can extend the language to create meaningful literals for your own types.

User-defined literals show how flexible C++ is and how you can make code closer to natural language.

Under the Hood

Literals are embedded directly in the compiled program as fixed values. The compiler assigns them types based on their form and suffixes. Constants declared with const or constexpr are stored in read-only memory or optimized away by the compiler. Const correctness is enforced by the compiler's type system, preventing code that tries to modify these values. User-defined literals are implemented as special functions called during compilation to convert literal syntax into objects.

Why designed this way?

C++ was designed to give programmers control over performance and safety. Constants prevent accidental changes, improving reliability. Literal suffixes and user-defined literals provide precise typing and expressiveness. The language balances low-level control with high-level safety features, allowing efficient and clear code. Alternatives like dynamic typing were rejected to keep performance predictable.

┌───────────────┐       ┌───────────────┐       ┌───────────────┐
│   Source      │──────▶│   Compiler    │──────▶│   Executable  │
│   Code with   │       │  parses       │       │  with fixed   │
│   literals &  │       │  literals &   │       │  literal &    │
│   constants   │       │  constants    │       │  constant     │
└───────────────┘       └───────────────┘       │  values       │
                                                └───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: do you think const variables can be changed later in the program? Commit to yes or no.

Common Belief: Const variables are just like regular variables and can be changed anytime.

Reality: Const variables cannot be changed after they are initialized; the compiler enforces this strictly.

Why it matters: Trying to change a const variable causes compile errors, and misunderstanding this can lead to wasted debugging time.

Quick: do you think literals always have the same type regardless of suffix? Commit to yes or no.

Common Belief: A number like 10 is always an int, no matter what.

Reality: The type of a literal depends on suffixes and format; 10u is unsigned int, 10L is long int, etc.

Why it matters: Ignoring literal types can cause unexpected behavior or bugs due to type mismatches.

Quick: do you think constexpr and const mean exactly the same? Commit to yes or no.

Common Belief: Constexpr is just a fancy const with no real difference.

Reality: Constexpr means the value is computed at compile time, enabling optimizations and compile-time checks, unlike const which may be runtime.

Why it matters: Confusing these can lead to missed optimization opportunities and harder-to-debug runtime errors.

Quick: do you think user-defined literals are only for advanced programmers and rarely useful? Commit to yes or no.

Common Belief: User-defined literals are complicated and not practical for everyday coding.

Reality: User-defined literals can make code more readable and expressive, especially in domains like units, currencies, or time durations.

Why it matters: Ignoring user-defined literals means missing out on writing clearer and safer domain-specific code.

Expert Zone

1

Const correctness applies not only to variables but also to pointers and member functions, affecting how objects can be used and modified.

2

Literal suffixes can affect overload resolution in functions, influencing which function version is called.

3

User-defined literals can be combined with templates and constexpr to create powerful compile-time computations.

When NOT to use

Avoid using const or constexpr when values must change during program execution, such as counters or user inputs. User-defined literals should not be overused for trivial cases as they can reduce code clarity. Instead, use regular functions or variables when flexibility is needed.

Production Patterns

Constants are widely used for configuration values, fixed parameters, and magic numbers replacement. constexpr is used for compile-time calculations like array sizes or mathematical constants. User-defined literals are common in libraries handling units (e.g., meters, seconds) or currencies to prevent errors and improve readability.

Connections

Type system

Constants and literals rely on the type system to define their behavior and safety.

Understanding how types work helps you grasp why constants prevent errors and how literals get interpreted.

Functional programming

Const correctness and immutability in C++ relate to the functional programming idea of avoiding state changes.

Knowing this connection helps appreciate why immutable values lead to safer and more predictable code.

Mathematics

Constants in programming are like mathematical constants (e.g., π), fixed values used in calculations.

Seeing constants as mathematical constants clarifies their role in making formulas and code reliable.

Common Pitfalls

#1 Trying to modify a const variable after initialization.

Wrong approach:

const int maxUsers = 100;
maxUsers = 200; // error: assignment of read-only variable

Correct approach:

const int maxUsers = 100;
// Use maxUsers as read-only value, do not assign again

Root cause:

Misunderstanding that const means the value cannot be changed after being set.

#2 Using a literal without the correct suffix causing type mismatch.

Wrong approach:

unsigned int x = 10; // 10 is int literal, may cause warning or conversion

Correct approach:

unsigned int x = 10u; // 'u' suffix makes literal unsigned int

Root cause:

Not knowing that literal suffixes control the literal's type.

#3 Confusing const and constexpr leading to runtime errors.

Wrong approach:

const int size = getSize(); // getSize() not constexpr, size not compile-time constant

Correct approach:

constexpr int size = 10; // known at compile time

Root cause:

Assuming const always means compile-time constant.

Key Takeaways

Literals are fixed values written directly in code, like numbers or text, and have specific types.

Constants are named values declared with const or constexpr that cannot be changed after initialization.

Using const and constexpr improves code safety, readability, and performance by preventing unwanted changes and enabling compile-time checks.

Literal suffixes let you control the exact type of a literal, avoiding bugs and improving clarity.

User-defined literals allow creating custom fixed values that make code more expressive and domain-specific.