> For the complete documentation index, see [llms.txt](https://learncpp.benntan.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://learncpp.benntan.com/memory-and-ownership/pointers.md). # Pointers ### Address of Variables So far, we've been working with variables like: {% code title="main.cpp" %} ```cpp int x = 10; ``` {% endcode %} But sometimes, we don't want the value itself, rather we will want to know **where is this value stored in memory?** The variable `x` could have some address like `0x100..`.
We don't know so lets find out using the ampersand `&` operator. {% code title="main.cpp" %} ```cpp int main() { int x = 10; std::cout << "location of x: " << &x << std::endl; } ``` {% endcode %}
### Type of Pointers We know the type of `x` is an `integer` , but what's the type of `&x` ? Instead of second guessing ourselves, let's rely on the C++ compiler to tell us. C++ offers a [`typeid` function ](https://en.cppreference.com/w/cpp/language/typeid.html)that seems useful: {% code title="main.cpp" %} ```cpp int main() { int x = 10; std::cout << typeid(x).name() << std::endl; std::cout << typeid(&x).name() << std::endl; } ``` {% endcode %}
The output may look cryptic but: * `i` (as you might have guessed) represents **int** * `Pi` (which you also might have guessed) represents **pointer to int** (`int*`) Indeed, we can write it like so:
CodeVisual Aid
int main()
{
    int x = 10;
    int* p = &x;
}
### De-referencing Given a pointer of type (`int *`), is there a way I can get the *actual* *value (*and not the address) it points to? In other words, {% code title="main.cpp" %} ```cpp int main() { int x = 10; int* p = &x; // can i get 10 using variable p alone? } ``` {% endcode %} Yes we can! Since the pointer `p` stores an address, we can dereference the pointer using `*` to get the value! Think of dereferencing as follow the address to get the value stored there.
CodeVisual Aid
int main()
{
    int x = 10;
    int* p = &x;
    int y = *p;

```
std::cout << "value of x: " << x << std::endl;
std::cout << "value of y: " << y << std::endl;
```

}
Realise while both values of x and y are the same, they are **not** pointing to the same 10. They each contain their own version of 10 (and possess their own memory addresses).
How do you make x and y to point to the same 10 then? Simple: we don't make two variables. We declare 1 variable and multiple pointers to the same variable. 
#include <iostream>

int main() {
int x = 10;
int\* y = \&x;   // y points to x
int\* z = \&x;   // z also points to x

```
std::cout << x << std::endl;   // 10
std::cout << *y << std::endl;  // 10

*y = 20;  // modify via pointer

std::cout << x << std::endl;   // 20 (x changed!)
```

}
### Pointer-Ception And yes because pointers also have addresses, we can have *pointers that point to a pointer that points to a value.*
CodeOutput
#include <iostream>

int main() {
    int x = 10;            // normal variable
    int* p = &x;           // pointer to x
    int** pp = &p;         // pointer to pointer

```
std::cout << "x value: " << x << std::endl;
std::cout << "Address of x (&x): " << &x << std::endl;

std::cout << "p (points to x): " << p << std::endl;
std::cout << "Value at p (*p): " << *p << std::endl;

std::cout << "pp (points to p): " << pp << std::endl;
std::cout << "Value at pp (*pp): " << *pp << std::endl;
std::cout << "Value at *pp (**pp): " << **pp << std::endl;

return 0;
```

}
--- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation by asking a question. Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters: ``` GET https://learncpp.benntan.com/memory-and-ownership/pointers.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.