C Developer - Lesson 2

The address-of operator & is a unary operator in C that returns the memory addressof a variable. Every variable in your program lives somewhere in the computer’s memory, and & gives you the exact location (address) where that variable is stored. The address is a number that identifies a specific byte in memory. You can store this address in a pointer variable and later use the dereference operator * to access the value at that address. Understanding & is essential for working with pointers, passing arguments by reference, and understanding how C manages memory.

#include <stdio.h>

int main() {
    int x = 5;
    printf("%d\n", *&x);
    return 0;
}

• *&x first takes the address of x with &x, then immediately dereferences it with *.
• The dereference follows the address back to the original variable and retrieves its value.
• *&x is equivalent to just x — it always gives the same result.
• This snippet demonstrates that & and * are inverse operations.
• The output is 5, the value of x.

#include <stdio.h>

int main() {
    int x = 5;
    int y = 5;
    printf("%d\n", &x == &y);
    return 0;
}

• Two different variables x and y, even with the same value (5), live at different memory addresses.
• &x == &y compares their addresses, which are always different.
• The comparison evaluates to 0 (false) because they are distinct memory locations.
• This shows that equal values do not mean equal addresses.
• Every variable gets its own unique memory location.

#include <stdio.h>

int main() {
    int x = 5;
    int* p = &x;
    printf("%d\n", p == &x);
    return 0;
}

• p is a pointer initialized with &x, the address of x.
• The expression p == &x compares the value stored in p (an address) with the address of x.
• Since p was set to &x, they are equal, so the result is 1 (true).
• This confirms that a pointer stores the exact address of the variable it points to.
• Comparing pointers with & is a way to check if a pointer points to a specific variable.

#include <stdio.h>

int main() {
    int a[3] = {10, 20, 30};
    printf("%d\n", &a[0] == &a[1]);
    return 0;
}

• Array elements are stored in contiguous (adjacent) memory locations.
• &a[0] is the address of the first element, &a[1] is the address of the second element.
• These addresses are different because each element occupies its own space in memory.
• &a[0] == &a[1] is 0 (false) since they are at different addresses.
• The distance between them is the size of one int (typically 4 bytes).

#include <stdio.h>

int main() {
    int x = 5;
    int* p = &x;
    int* q = &x;
    printf("%d\n", p == q);
    return 0;
}

• Two pointers p and q are both initialized with &x.
• Both pointers store the same address — the memory location of x.
• p == q compares the addresses stored in the two pointers.
• Since they hold identical addresses, the comparison is 1 (true).
• Multiple pointers can point to the same variable, and comparing them checks if they share the same target.

#include <stdio.h>

int main() {
    int x = 5;
    int y = 10;
    printf("%d\n", &x != &y);
    return 0;
}

• The != operator checks if two addresses are different.
• &x and &y are the addresses of two different variables.
• Since x and y are separate variables, their addresses are always different.
• &x != &y evaluates to 1 (true).
• This reinforces that every variable has a unique memory address.