{"title":"Constants & Literals (const, constexpr)","description":null,"content":"Some values in your program never change: the tax rate, the maximum number of items a cart can hold, the currency symbol on every price tag. C++ gives you two keywords (`const` and `constexpr`) for making those values immutable, plus a rich set of literal forms for writing numbers, characters, and strings directly in source code. This lesson covers both.\n\n---\n\n# Why Constants Exist\n\nWhen a value shouldn't change after you set it, encoding that into the type system saves you from a whole class of bugs. Consider a checkout function that accidentally overwrites the tax rate halfway through computing a total. With a regular variable, the compiler shrugs. With a `const`, the compiler refuses to build.\n\n\n```cpp\n#include \n\nint main() {\n double taxRate = 0.07;\n taxRate = 0.10; // legal, but is this what we wanted?\n\n const double FIXED_RATE = 0.07;\n // FIXED_RATE = 0.10; // error: assignment of read-only variable\n\n std::cout << \"Tax rate: \" << FIXED_RATE << std::endl;\n return 0;\n}\n```\n\n\nThe first assignment compiles. The commented-out one would not. That single line of compiler protection is the entire point of `const`: lock down values that shouldn't move, and let the compiler enforce it for you.\n\n---\n\n# `const` Variables\n\n`const` marks a variable as read-only after initialization. Two rules govern it:\n\n1. A `const` variable must be initialized at the point of declaration. You cannot declare it now and assign later.\n2. Once initialized, its value cannot be changed.\n\n\n```cpp\n#include \n\nint main() {\n const int MAX_ITEMS = 50;\n const double TAX_RATE = 0.07;\n const char CURRENCY = '$';\n\n std::cout << \"Max items per cart: \" << MAX_ITEMS << std::endl;\n std::cout << \"Tax rate: \" << TAX_RATE << std::endl;\n std::cout << \"Currency: \" << CURRENCY << std::endl;\n return 0;\n}\n```\n\n\nTry to break either rule and the compiler complains. Here's what each violation looks like:\n\n\n```cpp\nconst int MAX_ITEMS; // error: uninitialized 'const MAX_ITEMS'\nconst int LIMIT = 50;\nLIMIT = 100; // error: assignment of read-only variable 'LIMIT'\n```\n\n\nThe first error happens because `const` without an initializer leaves the variable with no defined value, and the compiler will never let you \"fix\" it later. The second error is the whole point: write-protection.\n\n### Naming Convention\n\nMost codebases write `const` names in `UPPER_SNAKE_CASE` to signal \"this won't move.\" It's a convention, not a language rule. The compiler treats `MaxItems`, `maxItems`, and `MAX_ITEMS` identically as long as you're consistent. The Naming Conventions lesson later in this section covers style choices in more detail.\n\n### `const` With Runtime Values\n\nA `const` doesn't have to know its value at compile time. It just has to be set when the variable is created and never changed afterward. This works fine:\n\n\n```cpp\n#include \n\nint main() {\n int itemsInStock;\n std::cout << \"Enter items in stock: \";\n std::cin >> itemsInStock;\n\n const int LOCKED_STOCK = itemsInStock; // value set at runtime, then frozen\n std::cout << \"Stock locked at: \" << LOCKED_STOCK << std::endl;\n return 0;\n}\n```\n\n\n**Sample Output:**\n\n\n```shell\nEnter items in stock: 12\nStock locked at: 12\n```\n\n\nThe compiler doesn't know what `LOCKED_STOCK` will be when it builds the program. It only knows that whatever value gets assigned during initialization is the value that stays. This is the key difference between `const` and `constexpr`, which we'll get to next.\n\n---\n\n# `constexpr` Variables\n\n`constexpr`, introduced in C++11, marks a value as known at compile time. The compiler evaluates the expression while building the program, bakes the result into the binary, and treats the name as a literal value everywhere it's used.\n\n\n```cpp\n#include \n\nint main() {\n constexpr double TAX_RATE = 0.07;\n constexpr int FREE_SHIPPING_THRESHOLD = 50;\n constexpr int MAX_CART_ITEMS = 100;\n\n double subtotal = 89.99;\n double tax = subtotal * TAX_RATE;\n\n std::cout << \"Subtotal: $\" << subtotal << std::endl;\n std::cout << \"Tax: $\" << tax << std::endl;\n std::cout << \"Free shipping at: $\" << FREE_SHIPPING_THRESHOLD << std::endl;\n std::cout << \"Max items: \" << MAX_CART_ITEMS << std::endl;\n return 0;\n}\n```\n\n\nSo far this looks identical to `const`. The difference shows up when you need a value at a place where the language requires a compile-time constant.\n\n### Where `constexpr` Buys You Something\n\nC++ has a handful of contexts that demand a compile-time integer. The two most common are array sizes and template arguments:\n\n\n```cpp\n#include \n\nint main() {\n constexpr int CART_CAPACITY = 5;\n double prices[CART_CAPACITY] = {19.99, 24.99, 9.99, 49.99, 14.99};\n\n for (int i = 0; i < CART_CAPACITY; i++) {\n std::cout << \"Item \" << (i + 1) << \": $\" << prices[i] << std::endl;\n }\n return 0;\n}\n```\n\n\nThe line `double prices[CART_CAPACITY]` only compiles because `CART_CAPACITY` is a `constexpr`. A plain `const int` works here too in many cases, but `constexpr` makes the intent explicit and works reliably across more contexts. If you tried this with a regular `int`, the compiler would reject it because the size of a built-in array must be fixed at compile time.\n\n`std::array` (covered in Arrays & Strings) takes its size as a template argument, which also requires a compile-time value:\n\n\n```cpp\n#include \n#include \n\nint main() {\n constexpr int CART_SIZE = 3;\n std::array prices = {19.99, 24.99, 9.99};\n\n for (double p : prices) {\n std::cout << \"$\" << p << std::endl;\n }\n return 0;\n}\n```\n\n\nThe compiler stamps out a `std::array` type while building. To do that, it needs `CART_SIZE` to be a value it can read at compile time. `constexpr` is the cleanest way to give it one.\n\n\n> **INFO**\n>\n> **Cost:** None at runtime. A `constexpr` value is computed once during compilation and substituted directly into the binary, so there's no lookup or memory access when the program runs.\n\n\n### `const` vs `constexpr`\n\nBoth make a variable read-only. The difference is when the value gets fixed.\n\n\n| Feature | `const` | `constexpr` |\n|---|---|---|\n| Initialization required | Yes | Yes |\n| Value can change after init | No | No |\n| Value can be a runtime expression | Yes | No, must be compile-time |\n| Usable as array size | Sometimes (integral types only) | Yes |\n| Usable as template argument | Sometimes | Yes |\n| Introduced in | Original C++ | C++11 |\n| Intent signal | \"Don't modify this\" | \"This is known at compile time\" |\n\n\nThe rule of thumb: if the value is known at compile time and you'd benefit from it being a true compile-time constant (array sizes, template parameters, performance), use `constexpr`. Otherwise, use `const`.\n\n\n```cpp\n#include \n\nint main() {\n constexpr double TAX_RATE = 0.07; // compile-time, used in calculations\n const std::string CUSTOMER = \"Priya\"; // runtime is fine\n constexpr int MAX_ITEMS = 50; // compile-time, may size an array\n const int itemsToday = MAX_ITEMS - 3; // const is fine, no array sizing here\n\n std::cout << \"Customer: \" << CUSTOMER << std::endl;\n std::cout << \"Tax rate: \" << TAX_RATE << std::endl;\n std::cout << \"Max items: \" << MAX_ITEMS << std::endl;\n std::cout << \"Items today: \" << itemsToday << std::endl;\n return 0;\n}\n```\n\n\nNote that you can't make a `std::string` a `constexpr` until C++20, because the type's constructor only became `constexpr` then. For string-like data, prefer `const` in C++17 code, or use a `const char*` if you really want compile-time storage:\n\n\n```cpp\nconstexpr const char* STORE_NAME = \"AlgoMaster Store\";\n```\n\n\n### `consteval` and `constinit` (Brief Mention)\n\nC++20 adds two more keywords in the same family: `consteval` (forces compile-time evaluation for functions) and `constinit` (forces compile-time initialization for variables with static or thread storage duration). They both refine cases where `constexpr` is too permissive. For now, just know they exist and don't reach for them yet.\n\n---\n\n# Literal Categories\n\nA literal is a value written directly in source code: `42`, `3.14`, `'A'`, `\"hello\"`, `true`, `nullptr`. C++ classifies them into a handful of categories, and each category has its own forms and rules.\n\n\n```mermaid\nflowchart TD\n LIT[Literals]:::cyan\n INT[Integer
42, 0x2A, 0b101010]:::orange\n FLOAT[Floating-point
3.14, 1.5e2, .5]:::orange\n CHAR[Character
'A', '\\\\n', '\\\\0']:::teal\n STR[String
"hello", R"(raw)"]:::teal\n BOOL[Boolean
true, false]:::green\n PTR[Pointer
nullptr]:::red\n\n LIT --> INT\n LIT --> FLOAT\n LIT --> CHAR\n LIT --> STR\n LIT --> BOOL\n LIT --> PTR\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n classDef red fill:#ff8787,stroke:#000,color:#000\n```\n\n\nThe diagram lays out the six families we'll walk through in the rest of this lesson. Each family has its own syntax, and most of them have suffixes that let you fine-tune the type.\n\n---\n\n# Integer Literals\n\nInteger literals can be written in four different bases. The base is determined by the prefix:\n\n\n| Form | Prefix | Example | Decimal value |\n|---|---|---|---|\n| Decimal | none | `42` | 42 |\n| Octal | `0` | `052` | 42 |\n| Hexadecimal | `0x` or `0X` | `0x2A` | 42 |\n| Binary | `0b` or `0B` | `0b101010` | 42 |\n\n\nBinary literals were added in C++14. The other three have been in C++ from the start.\n\n\n```cpp\n#include \n\nint main() {\n int decimal = 42;\n int octal = 052;\n int hex = 0x2A;\n int binary = 0b101010;\n\n std::cout << \"Decimal: \" << decimal << std::endl;\n std::cout << \"Octal: \" << octal << std::endl;\n std::cout << \"Hex: \" << hex << std::endl;\n std::cout << \"Binary: \" << binary << std::endl;\n return 0;\n}\n```\n\n\nAll four print as `42` because `std::cout` always formats integers as decimal by default. The prefix changes how the compiler reads the literal in source code, not how it stores or prints the value.\n\nThe leading-zero rule for octal trips up beginners often. `010` is not 10, it's 8. If you accidentally pad a literal with zeros to line up columns, you've changed its meaning. Stick to decimal unless you specifically want octal or have a reason to use hex or binary.\n\n### Integer Suffixes\n\nWithout a suffix, an integer literal is `int` by default. Suffixes promote it to a larger or unsigned type:\n\n\n| Suffix | Type | Example |\n|---|---|---|\n| `u` or `U` | unsigned | `42u` |\n| `l` or `L` | long | `42L` |\n| `ll` or `LL` | long long | `42LL` |\n| `ul`, `lu`, `UL`, etc. | unsigned long | `42UL` |\n| `ull`, `llu`, `ULL`, etc. | unsigned long long | `42ull` |\n\n\n\n```cpp\n#include \n\nint main() {\n auto a = 42; // int\n auto b = 42u; // unsigned int\n auto c = 42L; // long\n auto d = 42LL; // long long\n auto e = 42ull; // unsigned long long\n\n std::cout << \"Sizes (bytes): \"\n << sizeof(a) << \" \"\n << sizeof(b) << \" \"\n << sizeof(c) << \" \"\n << sizeof(d) << \" \"\n << sizeof(e) << std::endl;\n return 0;\n}\n```\n\n\n**Output (typical 64-bit Linux):**\n\n\n```shell\nSizes (bytes): 4 4 8 8 8\n```\n\n\nThe actual sizes are implementation-defined, but the relative ordering is fixed: `long long` is at least as big as `long`, which is at least as big as `int`. Suffixes only let you ask for \"at least this size.\"\n\nOrder doesn't matter for combinations. `42ull`, `42ULL`, `42llu`, and `42uLL` all mean the same thing. Mixed case is legal but reads poorly, so most teams stick to either all-lowercase or all-uppercase.\n\n### Digit Separator\n\nSince C++14, you can drop apostrophes between digits to make long literals readable. They're purely visual; the compiler ignores them.\n\n\n```cpp\n#include \n\nint main() {\n int populationOfDelhi = 33'000'000;\n long fileSizeBytes = 1'073'741'824L; // 1 GiB\n int binaryMask = 0b1111'0000'1010'0101;\n int hexAddress = 0xFF'AB'CD'12;\n\n std::cout << \"Population: \" << populationOfDelhi << std::endl;\n std::cout << \"File size: \" << fileSizeBytes << std::endl;\n std::cout << \"Mask: \" << binaryMask << std::endl;\n std::cout << \"Address: \" << hexAddress << std::endl;\n return 0;\n}\n```\n\n\nThe apostrophe can go between any two digits, in any base. Group them however reads best: threes for decimal, fours for binary, pairs for hex. The compiler doesn't care, but human readers do.\n\n---\n\n# Floating-Point Literals\n\nFloating-point literals have a decimal point, an exponent, or both. All of these are valid:\n\n\n| Literal | Value |\n|---|---|\n| `3.14` | three point one four |\n| `3.14e2` | 314.0 |\n| `3.14E-2` | 0.0314 |\n| `.5` | 0.5 |\n| `3.` | 3.0 |\n| `1e10` | 10,000,000,000.0 |\n\n\nThe decimal point or the exponent (the `e`/`E`) is what tells the compiler \"this is floating-point.\" Without either one, `3` is an integer.\n\n\n```cpp\n#include \n\nint main() {\n double price = 24.99;\n double discount = .15; // shorthand for 0.15\n double largePrice = 1.5e3; // 1500.0\n double tinyFraction = 2.5e-3; // 0.0025\n\n std::cout << \"Price: $\" << price << std::endl;\n std::cout << \"Discount: \" << discount << std::endl;\n std::cout << \"Bulk price: $\" << largePrice << std::endl;\n std::cout << \"Fraction: \" << tinyFraction << std::endl;\n return 0;\n}\n```\n\n\n### Floating-Point Suffixes\n\nWithout a suffix, a floating-point literal is `double`. Two suffixes change that:\n\n\n| Suffix | Type | Example |\n|---|---|---|\n| `f` or `F` | float | `3.14f` |\n| `l` or `L` | long double | `3.14L` |\n| (none) | double | `3.14` |\n\n\n\n```cpp\n#include \n\nint main() {\n float taxRateFloat = 0.07f;\n double taxRateDouble = 0.07;\n long double taxRateLD = 0.07L;\n\n std::cout << \"Sizes: \"\n << sizeof(taxRateFloat) << \" \"\n << sizeof(taxRateDouble) << \" \"\n << sizeof(taxRateLD) << std::endl;\n return 0;\n}\n```\n\n\n**Output (typical 64-bit Linux):**\n\n\n```shell\nSizes: 4 8 16\n```\n\n\nThe `f` suffix matters more than it looks. Without it, `0.07` is a `double`, and assigning a `double` to a `float` triggers a narrowing conversion that some compilers warn about. Writing `0.07f` says \"I meant a `float` from the start, no narrowing happening.\"\n\n---\n\n# Character Literals\n\nA character literal is a single character in single quotes. It has type `char` and represents one byte (on every system you're likely to use).\n\n\n```cpp\n#include \n\nint main() {\n char currency = '$';\n char grade = 'A';\n char digit = '7';\n\n std::cout << \"Currency: \" << currency << std::endl;\n std::cout << \"Grade: \" << grade << std::endl;\n std::cout << \"Digit char: \" << digit << std::endl;\n std::cout << \"Digit value: \" << static_cast(digit) << std::endl;\n return 0;\n}\n```\n\n\nThe last line is important: `'7'` is the character \"7\", not the number 7. Its underlying integer value is the ASCII code for `7`, which is 55. The Type Casting lesson covers conversions in detail.\n\n### Escape Sequences\n\nSome characters can't be typed directly (newline, tab) or would confuse the parser (quote, backslash). Escape sequences solve both problems:\n\n\n| Escape | Meaning | ASCII |\n|---|---|---|\n| `\\n` | Newline | 10 |\n| `\\t` | Tab | 9 |\n| `\\\\` | Backslash | 92 |\n| `\\'` | Single quote | 39 |\n| `\\\"` | Double quote | 34 |\n| `\\0` | Null character | 0 |\n| `\\r` | Carriage return | 13 |\n| `\\b` | Backspace | 8 |\n| `\\xHH` | Hex byte value (e.g., `\\x41` = 'A') | varies |\n| `\\NNN` | Octal byte value (e.g., `\\101` = 'A') | varies |\n\n\n\n```cpp\n#include \n\nint main() {\n std::cout << \"Customer:\\tPriya Sharma\" << std::endl;\n std::cout << \"Address:\\t221B Baker Street\" << std::endl;\n std::cout << \"Quote: \\\"Great service\\\"\" << std::endl;\n std::cout << \"Path: C:\\\\Users\\\\Priya\\\\orders\" << std::endl;\n std::cout << \"Hex A: \\x41\" << std::endl;\n return 0;\n}\n```\n\n\nThe null character `'\\0'` is special: it's how C-style strings mark their end. The C-Strings lesson in Arrays & Strings goes into detail. For now, treat `'\\0'` as \"byte value zero,\" distinct from the digit character `'0'` (whose value is 48).\n\n---\n\n# String Literals\n\nA string literal is a sequence of characters in double quotes. Its type is \"array of `const char`\" with one extra byte at the end for the null terminator `'\\0'`.\n\n\n```cpp\n#include \n\nint main() {\n std::cout << \"Welcome to the AlgoMaster Store\" << std::endl;\n std::cout << \"Featured product: Wireless Mouse\" << std::endl;\n return 0;\n}\n```\n\n\nThe escape sequences from the character section all work inside strings too:\n\n\n```cpp\n#include \n\nint main() {\n std::cout << \"Customer:\\tPriya\\nOrder:\\t#1042\\n\";\n return 0;\n}\n```\n\n\n### Adjacent String Concatenation\n\nTwo string literals written next to each other (separated only by whitespace, including newlines) are concatenated by the compiler into a single literal. This is purely a compile-time feature and happens before the program runs.\n\n\n```cpp\n#include \n\nint main() {\n const char* message = \"Welcome to \"\n \"the AlgoMaster Store \"\n \"where engineers shop.\";\n std::cout << message << std::endl;\n return 0;\n}\n```\n\n\nThis works because the three quoted pieces are all string literals sitting next to each other, and the compiler glues them. Notice there's no `+` between them. Trying to add a `+` would not work for plain string literals (they're not `std::string` objects yet at that stage).\n\nThis is useful for long messages that would otherwise need a very wide line. It also lets you mix regular and raw string literals (covered next).\n\n### Raw String Literals\n\nRaw string literals start with `R\"(` and end with `)\"`. Inside them, escape sequences are not interpreted. Backslashes are just backslashes.\n\n\n```cpp\n#include \n\nint main() {\n std::cout << \"Normal: C:\\\\Users\\\\Priya\\\\orders\\\\file.txt\" << std::endl;\n std::cout << R\"(Raw: C:\\Users\\Priya\\orders\\file.txt)\" << std::endl;\n return 0;\n}\n```\n\n\nRaw strings shine when the text contains lots of backslashes (Windows file paths, regular expressions) or lots of quotes (JSON, HTML, embedded SQL).\n\nWhat if the string itself needs to contain `)\"`? Use a custom delimiter between the `R\"` and the `(`:\n\n\n```cpp\n#include \n\nint main() {\n std::cout << R\"json({\"name\": \"Wireless Mouse\", \"price\": 24.99})json\" << std::endl;\n std::cout << R\"delim(This string has )\" in it.)delim\" << std::endl;\n return 0;\n}\n```\n\n\nThe delimiter between `R\"` and `(` can be any short identifier (up to 16 characters, no spaces). The same identifier must reappear in `)delim\"`. The compiler scans for `)` followed by your delimiter followed by `\"` to find the end.\n\nRaw strings also preserve line breaks literally, so multi-line strings stay multi-line without `\\n`:\n\n\n```cpp\n#include \n\nint main() {\n std::cout << R\"(Receipt\n==================\nWireless Mouse $24.99\nUSB-C Cable $9.99\n==================\nTotal $34.98)\" << std::endl;\n return 0;\n}\n```\n\n\n\n> **INFO**\n>\n> **Cost:** None. String literal concatenation and raw string parsing happen at compile time. The resulting string sits in read-only memory just like any other string literal.\n\n\n---\n\n# Boolean Literals\n\nTwo values: `true` and `false`. They're keywords, not just names defined somewhere, so you don't need to include any header to use them.\n\n\n```cpp\n#include \n\nint main() {\n bool isInStock = true;\n bool isOnSale = false;\n bool freeShipping = true;\n\n std::cout << \"In stock: \" << isInStock << std::endl;\n std::cout << \"On sale: \" << isOnSale << std::endl;\n std::cout << \"Free shipping: \" << freeShipping << std::endl;\n std::cout << std::boolalpha;\n std::cout << \"In stock (named): \" << isInStock << std::endl;\n return 0;\n}\n```\n\n\nBy default, `std::cout` prints booleans as `1` and `0`. Stream the manipulator `std::boolalpha` once, and it switches to the words `true` and `false` for the rest of that stream's lifetime. Stream Manipulators in the File I/O section covers this and related toggles.\n\n---\n\n# `nullptr`\n\n`nullptr` is the literal used to represent a null pointer, introduced in C++11. It replaces the older `NULL` macro (which expanded to `0` or `((void*)0)` depending on the platform) and the bare `0`. Both predecessors had subtle problems with overload resolution and template argument deduction. `nullptr` has its own type (`std::nullptr_t`) and converts cleanly to any pointer type.\n\n\n```cpp\n#include \n\nint main() {\n int* productPtr = nullptr;\n\n if (productPtr == nullptr) {\n std::cout << \"No product loaded yet\" << std::endl;\n }\n return 0;\n}\n```\n\n\nFor now, treat `nullptr` as the right way to say \"this pointer points to nothing.\"\n\n---\n\n# User-Defined Literals\n\nC++11 lets you define your own literal suffixes. For example, you can write `42_kg` and have it construct a `Mass` object. Library code uses this for things like `std::chrono::seconds`:\n\n\n```cpp\n#include \n#include \n\nint main() {\n auto deliveryWindow = std::chrono::hours(24) + std::chrono::minutes(30);\n using namespace std::chrono_literals;\n auto otherWindow = 24h + 30min;\n\n std::cout << \"Delivery window: \" << deliveryWindow.count() << \" minutes\" << std::endl;\n std::cout << \"Same window: \" << otherWindow.count() << \" minutes\" << std::endl;\n return 0;\n}\n```\n\n\nYou can write your own user-defined literals too, but the rules and corner cases are large enough to fill another lesson. For everyday code, the standard library's pre-built suffixes (chrono, complex numbers, string view) cover almost every reasonable use.\n\n---\n\n# Putting It Together\n\nA small e-commerce snippet that ties everything we've covered into one program:\n\n\n```cpp\n#include \n#include \n\nint main() {\n // Compile-time constants\n constexpr double TAX_RATE = 0.07;\n constexpr int FREE_SHIPPING_THRESHOLD = 50;\n constexpr int MAX_ITEMS = 100;\n\n // Runtime constants\n const char CURRENCY = '$';\n const std::string STORE = \"AlgoMaster Store\";\n\n // Literal forms\n int itemsInCart = 3; // decimal\n int permissionMask = 0b0000'0111; // binary, with separator\n int orderColor = 0xFF'AB'12; // hex, with separator\n double subtotal = 89.99; // double\n float discount = 0.10f; // float\n bool isPrimeCustomer = true; // boolean\n\n // Strings\n const char* welcomeMessage = \"Welcome to the \"\n \"AlgoMaster Store\";\n const char* receiptPath = R\"(C:\\Users\\Priya\\receipts\\order_1042.txt)\";\n\n // Math\n double tax = subtotal * TAX_RATE;\n double total = subtotal + tax - (subtotal * discount);\n bool qualifiesForFreeShipping = total >= FREE_SHIPPING_THRESHOLD;\n\n std::cout << welcomeMessage << std::endl;\n std::cout << \"Store: \" << STORE << std::endl;\n std::cout << \"Items in cart: \" << itemsInCart << \" (max \" << MAX_ITEMS << \")\\n\";\n std::cout << \"Subtotal: \" << CURRENCY << subtotal << std::endl;\n std::cout << \"Tax: \" << CURRENCY << tax << std::endl;\n std::cout << \"Total: \" << CURRENCY << total << std::endl;\n std::cout << std::boolalpha;\n std::cout << \"Prime customer: \" << isPrimeCustomer << std::endl;\n std::cout << \"Free shipping: \" << qualifiesForFreeShipping << std::endl;\n std::cout << \"Receipt: \" << receiptPath << std::endl;\n std::cout << \"Permission: \" << permissionMask << std::endl;\n std::cout << \"Color: \" << orderColor << std::endl;\n return 0;\n}\n```\n\n\nEvery constant, every literal form, every escape rule from earlier in the lesson shows up here. Reading this program once you understand the pieces is a good test of whether the material has settled.\n\n---\n\n# Summary\n\n- `const` makes a variable read-only after initialization, and the value can come from any expression including a runtime one.\n- `constexpr` is stronger: the value must be a compile-time constant, which lets it be used as an array size or template argument.\n- Both must be initialized at declaration. Reassigning either one is a compile error.\n- `consteval` and `constinit` (C++20) refine specific cases of compile-time evaluation.\n- Integer literals come in decimal (`42`), octal (`052`), hex (`0x2A`), and binary (`0b101010`, C++14). Suffixes `u`/`l`/`ll` and combinations like `42ull` choose the type.\n- Floating-point literals are `double` by default. Use `f` for `float` (`0.07f`) and `L` for `long double`. Forms include `3.14`, `.5`, `3.`, and exponents like `1.5e3`.\n- Digit separators (`1'000'000`, C++14) make long literals readable. The compiler ignores them.\n- Character literals use single quotes (`'A'`), strings use double quotes (`\"hello\"`). Escape sequences like `\\n`, `\\t`, `\\\\`, `\\0`, and `\\x41` cover special characters in both.\n- Raw string literals (`R\"(...)\"`) skip escape interpretation, which is invaluable for Windows paths, regex, JSON, and embedded SQL.\n- Boolean literals are `true` and `false`. `nullptr` is the modern null pointer literal, replacing `NULL` and bare `0`.\n\nIn the next lesson, we'll look at operators in C++: arithmetic, comparison, logical, and the rules that decide which one wins when several appear in the same expression.","pageType":"cpp"}

Constants & Literals (const, constexpr)

Get Premium