Variables and Basic Types

Chapter 1: Primitive Types

C++ inherits a set of built-in types (also called primitive types or arithmetic types) from C. These are the atomic building blocks: integers, floating-point numbers, characters, and booleans. Every other type in C++ is ultimately built from these.

Integer Types

The integer family comes in several sizes. The language guarantees minimum widths but not exact ones, which is why sizeof(int) can vary between platforms. On most modern 64-bit systems:

Each integer type can be signed (default, holds negatives) or unsigned (non-negative only, doubles the positive range). An unsigned char holds 0–255 instead of -128–127.

Floating-Point Types

Chapter 2: Variables — Naming Memory

A variable provides a named piece of storage. When you write int counter = 0;, three things happen: the compiler allocates 4 bytes on the stack, writes zero into those bytes, and records that the name counter refers to that location.

Definition vs Declaration

A definition allocates storage: int x = 5;. A declaration merely says "this name exists somewhere": extern int x;. You can declare a variable many times, but define it only once. This distinction becomes critical in multi-file programs.

Initialization

C++ has four ways to initialize a variable, and they are not all equivalent:

c++
int a = 0;       // copy initialization
int b(0);        // direct initialization
int c{0};        // list (brace) initialization — C++11
int d = {0};     // copy list initialization — C++11

List initialization (with braces) is the safest: the compiler will refuse to narrow. Writing int x{3.14}; is a compile error because 3.14 would lose precision. The other forms silently truncate.

Chapter 3: Const — Promises You Won't Change

The const qualifier is a promise to the compiler: "I will not modify this value after initialization." It sounds simple, but const interacts with references and pointers in subtle ways that trip up even experienced C++ programmers.

Top-Level vs Low-Level Const

This is the key distinction. Top-level const means the object itself can't be changed. Low-level const means the thing being pointed or referred to can't be changed through this handle.

c++
int i = 42;
const int ci = 42;         // top-level: ci itself is const
const int *p = &i;         // low-level: *p is const, p is not
int *const q = &i;         // top-level: q itself is const
const int *const r = &i;  // both levels

The rule of thumb: const before the * applies to what's pointed to (low-level). const after the * applies to the pointer itself (top-level).

constexpr

C++11 introduced constexpr to mark values that can be computed at compile time. A constexpr variable is implicitly const, but it also guarantees the value is known before the program runs.

c++
constexpr int size = 20;              // evaluated at compile time
constexpr int limit = size + 1;       // also compile time
int arr[limit];                        // OK: limit is a constant expression

Chapter 4: References — Aliases for Objects

A reference is an alternative name for an existing object. When you write int &r = x;, r becomes another name for x. It's not a copy — changing r changes x. Think of it as a sticky note placed on a box: the note isn't a new box, it's just another label on the same one.

References must be initialized when they are defined, and once bound, they cannot be rebound to a different object. This makes them much simpler (and safer) than pointers.

c++
int x = 10;
int &ref = x;    // ref is an alias for x
ref = 20;         // changes x to 20
// int &bad;       // ERROR: references must be initialized
// int &bad = 42;  // ERROR: can't bind non-const ref to literal

Const References

A reference to const (often called a "const reference") can bind to a literal, an expression, or an object of a different type — things a plain reference cannot do:

c++
const int &r1 = 42;         // OK: binds to a literal
const int &r2 = x * 2;      // OK: binds to a temporary
const double &r3 = x;       // OK: binds to a temporary double

Chapter 5: Pointers — Addresses as Values

A pointer holds the memory address of another object. Unlike a reference, a pointer is an object in its own right: it occupies memory (typically 8 bytes on a 64-bit system), it can be reassigned to point to different objects, and it can be null.

c++
int x = 42;
int *p = &x;      // p holds the address of x
*p = 99;           // dereference: changes x to 99
p = nullptr;       // p now points to nothing

The Dereference Operator

The * operator (dereference) follows the pointer to the object it points to. The & operator (address-of) gets the address of an object. They are inverses: *(&x) gives back x.

Null Pointers

A null pointer does not point to any object. In modern C++, always use nullptr (not NULL or 0). Dereferencing a null pointer is undefined behavior — the program may crash, produce garbage, or appear to work fine until the worst possible moment.

Chapter 6: Memory Map Explorer

Now let's put it all together. Every C++ program has its memory divided into regions: the stack (local variables, function call frames), the heap (dynamically allocated memory), the data segment (globals and statics), and the code segment (the program instructions).

The simulation below lets you step through a small C++ program and see exactly where each variable lives, what it contains, and which pointers and references connect them.

Chapter 7: Type Deduction — auto and decltype

C++11 introduced auto and decltype to let the compiler figure out types for you. This isn't laziness — it makes code more maintainable and prevents errors when types are complex.

auto

auto asks the compiler to deduce the type from the initializer:

c++
auto x = 42;         // int
auto pi = 3.14;      // double
auto s = "hello";    // const char*  (surprise!)
auto v = vec.begin();// vector<int>::iterator

auto drops top-level const and references. If you need them, say so explicitly:

c++
const int ci = 42;
auto a = ci;          // int, NOT const int (top-level const dropped)
const auto b = ci;    // const int
auto &c = ci;         // const int& (low-level const preserved)

decltype

decltype returns the exact type of an expression, including references and const. It does not evaluate the expression — it just inspects its type.

c++
int x = 5;
decltype(x) y = x;     // int (x is a variable)
decltype((x)) z = x;   // int& (parenthesized = lvalue expression)

Chapter 8: Beyond — Connections

This chapter covered the foundation of everything in C++. Every class, every template, every algorithm ultimately manipulates objects with types stored in memory. The concepts here — especially pointers, references, and const — will recur in every subsequent chapter.

What We Learned vs What Comes Next

Continue Reading

Next up: Chapter 3: Strings, Vectors, and Arrays — where we use these basic types to build the first real data structures.