Activity: Pointers

Brief Intro — Pointers

A pointer is one of the most powerful features of C, giving you a way to work directly with a computer's memory addresses. Rather than just holding a value, a pointer tells the program exactly where that data lives.

In this activity, you will master the address (&) and dereference (*) operators so you can manage memory with precision and efficiency.

Task 1: Addresses in Memory

Every variable is a memory location, and every memory location has its address defined. That address can be accessed using the ampersand (&) operator, which denotes an address in memory.

Task 2: Pointer Definition

A pointer is a variable whose value is the address of another variable, i.e., the direct address of a memory location. Like any variable or constant, you must declare a pointer before using it to store any variable address.

Task 3: Declaring Pointers

The general form of a pointer declaration is:

type *var-name;

Valid examples: int *ip; (pointer to an integer), double *dp;, float *fp;, char *ch;. The asterisk in the declaration designates the variable as a pointer.

Task 4: Pointer Types

The actual data type of the value of all pointers is the same — a long hexadecimal number that represents a memory address. The only difference between pointers of different data types is the data type of the variable that the pointer points to.

Task 5: The Three Steps

To use pointers, we frequently do three operations:

1. Define a pointer variable,
2. Assign the address of a variable to the pointer,
3. Access the value at the address using the unary * operator, which returns the value of the variable located at the address specified by its operand.

▶ Try it: Define & Point

Task 6: The Basic Trace

With int var = 20; int *ip; ip = &var;, the program prints the address of var and the address stored in ip (the same value), then Value of *ip variable: 20.

Task 7: The Working Example

Trace the notes' working example: c = 22; pc = &c; then c = 11; — *pc reads 11 because it reads whatever is at c's address — then *pc = 2; — this changes the value at the memory location pointed to by pc to 2, so c becomes 2. Use the visualizer above to step through these statements.

Task 8: Common Mistakes

Wanting pc to point to the address of c:

pc = c;   // Error, pc is address but c is not
*pc = &c; // Error, &c is address but *pc is not
pc = &c;  // Valid, both &c and pc are addresses
*pc = c;  // Valid, both c and *pc are values

Also: int *p = &c; is equivalent to int *p; p = &c; — in both cases we create pointer p (not *p) and assign &c to it.

Task 9: The NULL Pointer

It is good practice to assign a NULL value to a pointer when you do not have an exact address. A pointer assigned NULL is called a null pointer. NULL is a constant with a value of zero defined in several standard libraries. With int *ptr = NULL;, the program prints The value of ptr is 0.

Task 10: Why Address 0

In most operating systems, programs are not permitted to access memory at address 0 — that memory is reserved by the operating system. By convention, if a pointer contains the null (zero) value, it is assumed to point to nothing. To check for a null pointer: if(ptr) succeeds if ptr is not null; if(!ptr) succeeds if ptr is null.

Task 11: Passing by Reference / Address

Passing an argument by reference or by address enables the passed argument to be changed in the calling function by the called function. In the call-by-reference method, the address of the variable is passed as the parameter, and the value of the actual parameter can be modified by the formal parameter.

Task 12: Swap by Address Trace

void swap(int *a, int *b) {
    int tmp;
    tmp = *a;
    *a = *b;
    *b = tmp;
}

In swap(&m, &n) with m = 22, n = 44, the parameters a and b hold the addresses of m and n. They are not copied — the addresses are used to access and change the variables. Output:

Values before swap m = 22 and n = 44
Values after swap a = 44 and b = 22

▶ Try it: Trace Swap