# 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
#include <iostream>

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;

return 0;
```

}
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: " << x << std::endl;        // 10
std::cout << "*y: " << *y << std::endl;      // 10
std::cout << "*z: " << *z << std::endl;      // 10

*y = 20;  // modify x via pointer y

std::cout << "x: " << x << std::endl;   // 20
std::cout << "*z: " << *z << std::endl; // 20

return 0;
```

}
### 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;
```

}