🦋Pointers

Address of Variables

So far, we've been working with variables like:

main.cpp

int x = 10;

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.

main.cpp

int main() {
    int x = 10;
    std::cout << "location of x: " << &x << std::endl;
}

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 that seems useful:

main.cpp

int main() {
    int x = 10;
    std::cout << typeid(x).name() << std::endl;
    std::cout << typeid(&x).name() << std::endl;
}

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:

Code	Visual 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,

main.cpp

int main() {
    int x = 10;
    int* p = &x;
    
    // can i get 10 using variable p alone?
}

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.

Code	Visual 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.

main.cpp #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.

Code

Output

main.cpp #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; }