Pointers and Memory Addresses

A pointer is a typed value that stores the address of an object. It lets a function reach caller-owned data, lets array traversal describe a current position, and makes memory relationships explicit—but only while the address, lifetime, type, and valid range all agree.

Every safe pointer answers four questions

An object and its address are different values

int score = 18; creates an int object named score. The expression score reads its value, 18. The expression &score produces the address where that object lives. Because the object is an int, the address has type int *—“pointer to int.”

A real address may look like 0x7ffd..., but its numeric spelling is not the useful contract. Addresses can differ across runs, machines, optimization levels, and operating systems. Reason from identity—“the address of score”—instead of memorizing a particular number.

#include <stdio.h>

int main(void) {
  int score;

  printf("Enter a score: ");
  scanf("%d", &score);
  printf("Stored score: %d\n", score);
  return 0;
}

Edit the program, predict its output, then run it.

Declare the pointed-to type, then initialize the pointer

int score = 18;
int *score_pointer = &score;

printf("value: %d\n", score);
printf("address: %p\n", (void *)&score);
printf("stored address: %p\n", (void *)score_pointer);

The star in int *score_pointer belongs to the declaration: it says the variable stores the address of an int. Initialize a pointer at declaration whenever possible. An uninitialized local pointer has an indeterminate value; following it is not a search for a useful object—it is undefined behavior.

Dereference means “the object at this address”

If score_pointer contains &score, then *score_pointer designates the same object as score. In a value expression it reads the object. On the left side of assignment it writes the object.

int score = 18;
int *score_pointer = &score;

printf("before: %d\n", *score_pointer);
*score_pointer = 20;
printf("after: %d\n", score);

The pointer is not the integer 18 and it is not another score object. It stores an address. The dereferenced expression identifies the original object, so the assignment changes what a later read through score observes.

A pointer parameter creates an explicit mutation channel

C passes every argument by value, including pointers. A function receives a copy of the address, but both the caller's pointer expression and the parameter can lead to the same object. That is how a function can update caller-owned data without C having a separate pass-by-reference mechanism.

void add_bonus(int *score, int bonus) {
  if (score == NULL) {
    return;
  }
  *score = *score + bonus;
}

int main(void) {
  int result = 16;
  add_bonus(&result, 2);
  printf("%d\n", result);
  return 0;
}

1. 01
   The caller takes an address

   &result identifies the caller-owned int.

2. 02
   The call copies that pointer value

   The parameter score receives its own pointer value, not a new integer object.

3. 03
   The function validates the address

   The null check proves the pointer represents an object before dereference.

4. 04
   Dereference reaches shared storage

   *score designates result, so assignment is visible to the caller.

NULL means “no object,” not “safe object”

NULL is a null pointer constant. Use it when a pointer deliberately refers to no object yet or when “not found” is part of an interface. It is valid to assign, compare, or return a null pointer. It is never valid to dereference one.

Array expressions connect indexing to pointer arithmetic

In most expressions, an array name converts to a pointer to its first element. For int scores[4], the expression scores usually has the same value as &scores[0]. This is why a function parameter written as int scores[] behaves as int *scores.

Pointer arithmetic advances in elements, not raw bytes. If cursor points to an int, cursor + 1 points to the next int. The identity scores[index] == *(scores + index) explains array indexing; it does not remove the need for a count.

#include <stdio.h>

int main(void) {
  int scores[4] = {12, 15, 18, 20};

  scores[1] = scores[1] + 2;
  printf("Updated: %d\n", scores[1]);
  printf("Third: %d\n", scores[2]);
  return 0;
}

Edit the program, predict its output, then run it.

Place const according to what must not change

An address is valid only during the object's lifetime

A local object normally lives from the execution of its declaration until control leaves its block. Returning &local_value from a function produces a pointer to an object whose lifetime ends as the function returns. The address may still look plausible, but dereferencing it is undefined behavior.

int *broken_result(void) {
  int local_value = 42;
  return &local_value; /* wrong: local_value soon stops existing */
}

Later, dynamic allocation introduces another lifetime boundary: allocated storage remains alive until free, and every retained pointer to it becomes invalid after that call. For now, prefer addresses of caller-owned objects whose lifetime clearly covers the function call.

Print addresses with %p and void *

Use printf("%p\n", (void *)pointer); for diagnostic address output. Do not use %d: an address is not an int, and mismatching a variadic format with its argument type is undefined behavior. Treat the printed address as temporary diagnostic evidence, not stable application data.

Independent lab: update caller-owned readings safely

First run the browser starter to practice supplying three valid element addresses to scanf. Then copy the local-compiler extension below and replace each indexed update with a small pointer function. Keep the count beside the pointer whenever more than one element is accessible.

#include <stdio.h>

int main(void) {
  int readings[3] = {0, 0, 0};
  int total = 0;

  scanf("%d %d %d", &readings[0], &readings[1], &readings[2]);
  for (int index = 0; index < 3; index++) {
    total = total + readings[index];
  }

  printf("Total: %d\n", total);
  return 0;
}

Edit the program, predict its output, then run it.

void increase_all(int *values, int count, int amount) {
  if (values == NULL || count < 0) {
    return;
  }

  for (int index = 0; index < count; index++) {
    *(values + index) += amount;
  }
}

Lesson review

• &object produces the object's address; its pointer type follows the object type.
• *pointer designates the pointed-to object only when the pointer is valid to dereference.
• C passes a pointer parameter by value, but that copied address can still reach caller-owned storage.
• A pointer does not carry an array length. Pass the valid element count separately.
• Pointer arithmetic advances by pointed-to elements and must remain within one array object or its one-past boundary.
• NULL represents no object and must be checked before dereference when the contract permits it.
• Uninitialized and dangling pointers do not identify objects you may safely access.
• Use const int * for read-only element access and %p with void * for diagnostic address output.