{"title":"Pointers Basics","description":null,"content":"A pointer is a variable that holds the address of another variable. That single idea unlocks dynamic data structures, efficient parameter passing, and direct access to memory, and it's also responsible for a large fraction of C++ bugs. This chapter covers what a pointer actually is, how to declare one, how to read and write the value it points at, and why an uninitialized pointer is one of the most dangerous things you can leave lying around in your code.\n\n---\n\n# Memory Addresses, in One Picture\n\nBefore pointers make sense, the idea of a memory address needs to feel concrete. When your program runs, every variable lives in memory, and memory is just a long sequence of numbered byte slots. The \"number\" of a slot is its address. The C++ compiler decides where to put each variable, and from then on the variable's storage has a fixed address until that variable goes out of scope.\n\nSuppose you declare two variables for a small product:\n\n\n```cpp\nint stock = 42;\ndouble price = 19.99;\n```\n\n\nThe compiler picks an address for each. On a 64-bit machine `stock` takes 4 bytes and `price` takes 8 bytes, so they might land at addresses like this:\n\n\n```mermaid\nflowchart LR\n subgraph STACK[Stack memory]\n S[\"stock
value: 42
address: 0x7ffd0010\"]:::cyan\n P[\"price
value: 19.99
address: 0x7ffd0014\"]:::orange\n end\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n```\n\n\nThe diagram shows two variables sitting in memory, each with a value and an address. The actual addresses you'd see on your machine will look different, but the shape is the same. Every variable has both a value (`42`, `19.99`) and a location (`0x7ffd0010`, `0x7ffd0014`).\n\nA pointer is just a variable whose value is one of those addresses. Instead of storing `42` or `19.99`, it stores the location where a `42` or `19.99` lives. Once you have that location, you can read or write the variable through the pointer.\n\n---\n\n# Declaring a Pointer\n\nA pointer declaration uses a `*` between the type and the name. The type tells the compiler what kind of thing the pointer points at, which matters because reading or writing through the pointer needs to know how many bytes to move and how to interpret them.\n\n\n```cpp\nint* p; // pointer to an int\ndouble* q; // pointer to a double\nchar* r; // pointer to a char\n```\n\n\nRead each declaration as \"pointer to X\". `int* p` is \"p is a pointer to int\". The `int` is the pointee type. The `*` says \"this name is a pointer\". The compiler doesn't care whether you write `int* p`, `int *p`, or `int * p`. All three declare the same thing. The course style sticks with `int* p`, because it keeps the type and the pointer-ness together visually.\n\nHere's the wart that catches people: in a multi-variable declaration, the `*` only applies to the name immediately next to it.\n\n\n```cpp\nint* a, b; // a is int*, b is int (probably not what you meant)\nint *a, *b; // both are int* (clearer if you must declare two on one line)\nint* a; // declare them on separate lines instead\nint* b;\n```\n\n\nThe clean rule: declare one pointer per line. You'll see code that does otherwise, and the bug surface isn't worth it.\n\nA pointer variable, like any other variable, has its own storage and its own address. The pointer holds an address, but the pointer itself also lives somewhere in memory.\n\n---\n\n# Getting an Address with `&`\n\nTo put something useful into a pointer, you need a way to ask \"what's the address of this variable?\". The address-of operator `&` does that. Put `&` in front of a variable name and it produces the address where that variable lives.\n\n\n```cpp\n#include \n\nint main() {\n int stock = 42;\n int* p = &stock;\n\n std::cout << \"stock's value: \" << stock << std::endl;\n std::cout << \"stock's address: \" << &stock << std::endl;\n std::cout << \"p holds: \" << p << std::endl;\n return 0;\n}\n```\n\n\nThe exact address will differ on every run, on every machine, and even between debug and release builds. What matters is that `&stock` and `p` print the same value: both are the address where `stock` lives. The pointer `p` doesn't make a copy of `stock`; it just notes down where `stock` is.\n\nSome properties of `&`:\n\n- It only works on things that have an address, called **lvalues** in C++. Variables have addresses. Temporary results (like `2 + 3`) don't, and `&(2 + 3)` is a compile error.\n- The result has type \"pointer to whatever was on the right\". `&stock` is `int*` because `stock` is `int`. `&price` is `double*` because `price` is `double`.\n- The same `&` symbol means something different in a parameter list (`void f(int& x)` declares a reference, covered later in this section). For now, just remember: `&` next to an existing variable expression produces an address.\n\nThe type of the pointer and the type of the variable have to match. You can't store the address of a `double` in an `int*`:\n\n\n```cpp\ndouble price = 19.99;\nint* p = &price; // compile error: cannot convert 'double*' to 'int*'\n```\n\n\nThe compiler stops this on purpose. An `int*` and a `double*` would read different numbers of bytes and interpret them in different ways, so silently mixing them would corrupt data. The matching rule is what makes pointers safe to use, as long as you stay inside the rule.\n\n---\n\n# Reading and Writing Through a Pointer with `*`\n\nA pointer is only useful if you can use it to reach the thing it points at. The dereference operator `*` does that. Put `*` in front of a pointer expression and you get the value at that address.\n\n\n```cpp\n#include \n\nint main() {\n int stock = 42;\n int* p = &stock;\n\n std::cout << \"stock: \" << stock << std::endl;\n std::cout << \"*p: \" << *p << std::endl;\n\n *p = 100; // write through the pointer\n\n std::cout << \"stock after *p = 100: \" << stock << std::endl;\n return 0;\n}\n```\n\n\nTwo things to notice. First, `*p` and `stock` print the same number, because `p` points at `stock`, so reading \"the value at that address\" is the same as reading `stock` directly. Second, writing `*p = 100` doesn't change `p`. The pointer still holds the same address. What changes is the value sitting at that address. After the assignment, `stock` itself is `100`, because `p` and `stock` are two ways of talking about the same memory.\n\nThis is the part that takes a moment to internalize: a pointer gives you an alias for the thing it points at. Anything you do with `*p` happens to the original variable. There's no copy, no separate buffer.\n\nThe same `*` shows up in two different roles, and that's worth pulling apart:\n\n- In a **declaration**, `*` means \"this name is a pointer\": `int* p;`.\n- In an **expression**, `*` is the dereference operator: `*p` reads or writes the pointed-to value.\n\nSo `int* p = &stock;` declares a pointer and initializes it, and `*p = 100;` writes through it. Same symbol, different jobs, easy to confuse at first.\n\nA pointer to a struct works the same way. Reach the struct with `*`, then use a member with `.`:\n\n\n```cpp\n#include \n#include \n\nstruct Product {\n std::string name;\n double price;\n};\n\nint main() {\n Product mouse{\"Wireless Mouse\", 24.99};\n Product* p = &mouse;\n\n std::cout << (*p).name << \" costs $\" << (*p).price << std::endl;\n\n (*p).price = 19.99; // discount applied through the pointer\n std::cout << \"After discount: $\" << mouse.price << std::endl;\n return 0;\n}\n```\n\n\nThe parentheses around `*p` are needed because `.` binds tighter than `*`. Writing `*p.name` would be parsed as `*(p.name)`, which doesn't make sense for a pointer. C++ provides a shorthand for this exact pattern: `p->name` means the same thing as `(*p).name`. Most code uses `->` for pointer-to-struct member access because it reads more cleanly.\n\n\n```cpp\nstd::cout << p->name << \" costs $\" << p->price << std::endl;\n```\n\n\nYou'll see `->` everywhere in real C++ code that touches pointers to objects.\n\n---\n\n# How Big Is a Pointer?\n\nThe size of a pointer is set by the machine's address width, not by the type of thing it points at. On a 64-bit system every pointer is 8 bytes, because that's how many bytes are needed to hold a 64-bit address. On a 32-bit system every pointer is 4 bytes. A pointer to an `int` and a pointer to a `Product` with a hundred members are exactly the same size.\n\n\n```cpp\n#include \n#include \n\nstruct Product {\n std::string name;\n double price;\n int stock;\n std::string category;\n std::string description;\n};\n\nint main() {\n int x = 0;\n Product big{};\n\n std::cout << \"sizeof(int): \" << sizeof(int) << std::endl;\n std::cout << \"sizeof(Product): \" << sizeof(Product) << std::endl;\n std::cout << \"sizeof(int*): \" << sizeof(int*) << std::endl;\n std::cout << \"sizeof(Product*): \" << sizeof(Product*) << std::endl;\n std::cout << \"sizeof(&x): \" << sizeof(&x) << std::endl;\n std::cout << \"sizeof(&big): \" << sizeof(&big) << std::endl;\n return 0;\n}\n```\n\n\n**Output (typical 64-bit machine):**\n\n\n```shell\nsizeof(int): 4\nsizeof(Product): 104\nsizeof(int*): 8\nsizeof(Product*): 8\nsizeof(&x): 8\nsizeof(&big): 8\n```\n\n\nThe `Product` itself takes about 104 bytes on this machine (the exact number depends on the standard library implementation and padding), but a `Product*` still takes 8 bytes. That's the practical reason \"pass by pointer\" or \"pass by reference\" is cheaper than \"pass by value\" for large types: handing over an 8-byte address is much cheaper than copying a hundred-byte struct.\n\n\n> **INFO**\n>\n> **Cost:** Pointers are uniformly small, which is what makes them useful for cheap sharing of large data. An array of `Product*` is `N * 8` bytes regardless of how big each `Product` is, where an array of `Product` is `N * sizeof(Product)`.\n\n\nThe pointer's type doesn't affect its size, but it does affect how the pointer is used. An `int*` and a `double*` are both 8 bytes, but dereferencing each one reads a different number of bytes (4 vs 8) and interprets them differently. The size of a pointer and the size of the thing it points at are separate properties.\n\n---\n\n# Reading Pointer Declarations Naturally\n\nPointer declarations get easier when you read them in a consistent direction. The trick is to read from the variable name outward, replacing each piece with English as you go.\n\nStart simple:\n\n\n```cpp\nint* p;\n```\n\n\nRead it right-to-left from the name: \"`p` is a pointer to `int`\".\n\nA few more:\n\n\n```cpp\ndouble* price_ptr; // price_ptr is a pointer to double\nchar* customer_name; // customer_name is a pointer to char\nProduct* current; // current is a pointer to Product\n```\n\n\nFor now, every example you'll meet in this chapter has only one `*` and no `const`. Later chapters in this section add `const` placement and pointers to pointers, which complicate the reading rule. The chapter on \"const & Pointers\" covers the formal \"spiral rule\" for those cases. The starter version works for everything in this lesson.\n\nA pointer declaration is also just a variable declaration. The same rules apply: it has a name, a type, optional initializer, and scope. The only twist is that the type happens to be \"pointer to something\".\n\n---\n\n# Uninitialized Pointers Are a Trap\n\nA regular `int` you forget to initialize holds a garbage value. Annoying, but recoverable: you read the wrong number and the program prints the wrong total. A pointer you forget to initialize holds a garbage address, and dereferencing it doesn't just give you a wrong value, it reads or writes some unrelated piece of memory. The consequences range from \"program crashes immediately\" to \"program runs for a week and then corrupts the database\".\n\nThis is the classic \"wild pointer\" bug:\n\n\n```cpp\n#include \n\nint main() {\n int* p; // declared but not initialized\n std::cout << *p; // undefined behavior: dereferencing a wild pointer\n return 0;\n}\n```\n\n\n`p` is a local variable holding whatever bits happened to be in its stack slot at the moment it was created. Those bits get interpreted as an address. The compiler doesn't zero-initialize local variables for you, and there's no runtime check that flags this when you dereference. The program might segfault, might print whatever number happens to sit at that address, or might appear to work and silently corrupt something else. All three are valid outcomes of undefined behavior, and you can see different results on different compilers, optimization levels, or even runs of the same binary.\n\nThe fix is to always give a pointer a sensible value when you create it. There are three good options:\n\n**1. Point it at something real right away:**\n\n\n```cpp\nint stock = 42;\nint* p = &stock;\n```\n\n\n**2. Use it only after assigning a real address later:**\n\n\n```cpp\nint* p;\n// ... some code that decides what p should point at ...\nint stock = 42;\np = &stock;\nstd::cout << *p << std::endl; // safe now\n```\n\n\n**3. Initialize it to \"no address\" with `nullptr`:**\n\n\n```cpp\nint* p = nullptr;\n```\n\n\n`nullptr` is a special pointer value that represents \"this pointer doesn't point at anything yet\". You can copy it, compare it (`p == nullptr`), and pass it around safely, but dereferencing a `nullptr` is still undefined behavior (it usually segfaults). The role of `nullptr` is to make \"empty\" an explicit, checkable state instead of a random garbage value. We'll cover the full mechanics in the dedicated `nullptr` chapter; for this chapter, treat it as the standard way to say \"no address right now\".\n\nHere's a side-by-side of the two bad states a pointer can be in:\n\n\n| Pointer state | What it holds | Safe to dereference? |\n|---------------|---------------|----------------------|\n| Wild (uninitialized) | Garbage bits | No, undefined behavior |\n| Null (`nullptr`) | A sentinel value meaning \"nothing\" | No, undefined behavior, but easy to check for |\n| Pointing at a valid object | The address of that object | Yes |\n\n\nThe crucial difference: a null pointer is a known bad state that you can detect with `if (p != nullptr)`. A wild pointer looks like a valid pointer to the compiler; there's no way to tell at runtime that it points at garbage.\n\n\n> **INFO**\n>\n> **Cost:** Initializing pointers to `nullptr` is free at runtime, and it lets you write defensive checks. Wild pointers cost nothing too, until they corrupt your program in a way that takes hours to debug.\n\n\n---\n\n# A Worked Example: Updating Stock Through a Pointer\n\nPutting the pieces together, here's a small program that uses a pointer to apply a stock restock to a product. The pointer pattern shows up often when one piece of code wants to modify a value that's owned by another piece of code without copying the data around.\n\n\n```cpp\n#include \n#include \n\nstruct Product {\n std::string name;\n int stock;\n};\n\nvoid restock(Product* p, int amount) {\n if (p == nullptr) {\n std::cout << \"Nothing to restock.\" << std::endl;\n return;\n }\n p->stock = p->stock + amount;\n}\n\nint main() {\n Product mouse{\"Wireless Mouse\", 5};\n\n std::cout << mouse.name << \" stock before: \" << mouse.stock << std::endl;\n restock(&mouse, 10);\n std::cout << mouse.name << \" stock after: \" << mouse.stock << std::endl;\n\n Product* nothing = nullptr;\n restock(nothing, 7);\n\n return 0;\n}\n```\n\n\n`restock` takes a `Product*`, which means it receives the address of a product rather than a copy of one. Inside the function, `p` aliases the caller's `mouse`, so `p->stock = p->stock + amount` modifies the same `stock` field that `main` sees. After the call, `mouse.stock` is `15`, not because the function returned a new value, but because it updated the original through the pointer.\n\nThe null check at the top of `restock` is the defensive pattern that goes with pointer parameters. If the caller passes a null pointer (as the second call does, deliberately), the function detects it and bails out instead of dereferencing and crashing. That kind of check is one of the reasons `nullptr` exists as an explicit \"no address\" value rather than relying on uninitialized memory.\n\nThis chapter is stopping short of the rest of the pointer machinery on purpose. Pointer arithmetic, references as an alternative syntax, `const` placement, allocating memory with `new`, and detecting dangling pointers are all coming up in the next chapters of this section. With just declaration, address-of, and dereference, you can already see the core idea: a pointer is an address, and dereferencing it gets you to the thing at that address.\n\n---\n\n# Summary\n\n- A pointer is a variable that stores the address of another variable. The pointer's type (`int*`, `double*`, `Product*`) tells the compiler what kind of thing lives at that address.\n- Declare a pointer with `Type* name`. Take an address with `&variable`. Read or write the pointed-to value with `*pointer`. Use `->` as shorthand for `(*pointer).member` on struct pointers.\n- The size of a pointer depends on the machine's address width, not on the pointee. On a 64-bit system every pointer is 8 bytes, whether it points at an `int` or a 100-byte struct.\n- Pointer types have to match the type of the variable being pointed at. An `int*` can't hold the address of a `double`. The compiler enforces this so that dereferences read the right number of bytes.\n- An uninitialized pointer holds a garbage address. Dereferencing it is undefined behavior and can crash, print nonsense, or silently corrupt unrelated data. Always initialize pointers, either to a real address or to `nullptr`.\n- `nullptr` represents \"no address right now\". It's safe to copy and compare, but dereferencing it is still undefined behavior.\n- Read a pointer declaration from the variable name outward: `int* p` is \"`p` is a pointer to int\". For a single `*`, that's all you need; more complex forms come up when `const` enters the picture.\n- Assigning to a pointer (`p = &x`) changes which address it holds. Assigning through a pointer (`*p = value`) changes the value at the current address. These are different operations and easy to confuse early on.\n\nIn the next chapter, we'll look at pointer arithmetic: what happens when you add an integer to a pointer, why `p + 1` doesn't always mean \"one byte forward\", and how this connects pointers to arrays.","pageType":"cpp"}

Pointers Basics

Get Premium