C Pointers, Arrays, and Strings¶

L04 C Pointers, Arrays, Strings | CS61C: Course Notes

Memory, Addresses, and Pointers¶

Memory Layout in Simplified Model¶

For now, picture all of memory as one huge array that starts at address 0x00000000.

A useful analogy:

• Each cell is a house on a very long street.

• The house number is the memory address.

• The person living inside is the byte value stored there.

In this model:

• Each cell is one byte wide.

• Every byte has its own address.

• A byte at some address also has a value. For example, the byte at 0x00000104 might store the ASCII character 'b' (0b01100010).

Variable names usually refer to blocks of memory, not just a single byte. For example, an unsigned 32-bit integer x with value 0x12345678 occupies 4 consecutive bytes. By convention, the address of x is the address of its first (lowest) byte—say 0x00000100.

Pointers Store Addresses¶

A pointer is simply:

A variable that contains the address of another variable.

If pointer p “points to” x, that means p stores the address of x (for example 0x00000100), not the value of x itself.

Because pointers are also variables, they live somewhere in memory too—so a pointer itself also has an address.

“Following” a pointer means accessing the value it points to. This is called dereferencing. If we follow p, we get the value of x.

C requires pointers to be typed. The type tells the compiler how many bytes to read when following the pointer. For example, if p is a pointer to a 32-bit unsigned integer, following p reads 4 bytes starting at that address—not just one byte.

We will look at pointer syntax next.

Pointers and Bugs¶

Pointer Syntax¶

• Declare

  int x = 3;
  int *p;
  

  

  • Tells compiler that variable p is address of an integer.

• Assign with address operator &

  p = &x;
  

  

  • Tells compiler to assign the address of x to p.

• Dereference with *

  printf("p points to %d\n", *p);
  

  

• Dereference and assign with *

  *p = 5;
  

  

Garbage Addresses and NULL Pointers¶

Like other local variables, declaring a pointer does not initialize it—it only allocates space to hold an address. Whatever leftover bits are there get treated as an address:

int *ptr;
*ptr = 5;  /* dangerous: ptr holds garbage */

This may compile (often with warnings), but writing through a garbage address is undefined behavior—you might overwrite some random part of memory.

The special all-zero address is the NULL pointer (similar to Python’s None or Java’s null). Address 0x0 is reserved: reading or writing through it causes a runtime error.

Setting a pointer to NULL is useful as a sentinel: it means “this pointer does not point to a valid object.”

if (!p) { /* p is NULL */ }
if (q)  { /* q is not NULL */ }

Pointer Operations¶

Pointer Arithmetic¶

Pointers support addition and subtraction. The key idea of this is that the compiler strides by the size of the pointed-to type.

• ptr + n adds n * sizeof(*ptr) bytes to the address in ptr

• ptr - n subtracts n * sizeof(*ptr) bytes

int *ptr;          /* assume int is 4 bytes */
ptr + 5;           /* advances by 5 * 4 = 20 bytes, not 5 */

You cannot add two pointers together, but you can subtract two pointers of the same type (the result is how many elements apart they are).

Pointer arithmetic is especially useful when walking through arrays.

Struct Pointers¶

Structs can be large, so we often pass around pointers to them.

typedef struct {
  int x;
  int y;
} coord_t;

coord_t coord1;
coord_t *ptr1 = &coord1;

int h = coord1.x;   /* dot: access member of a struct value */
int k = (*ptr1).x;  /* dereference, then access member */
k = ptr1->x;        /* arrow: shorthand for (*ptr1).x */

• . accesses a member of a struct value

• -> is shorthand for “dereference, then access a member”

Assigning one struct pointer to another copies the address, so both pointers refer to the same struct in memory:

ptr1 = ptr2;  /* both now point to the same object */

Double Pointers¶

Because C is pass-by-value, a function cannot update a caller’s pointer if it only receives a copy of that pointer:

void increment_ptr(uint32_t *p) {
    p = p + 1;  /* only changes the local copy */
}

uint32_t arr[] = {50, 60, 70};
uint32_t *q = arr;
increment_ptr(q);  /* q still points to 50 */

To change the pointer itself, pass a pointer to a pointer (a double pointer / handle):

void increment_ptr(uint32_t **h) {
    *h = *h + 1;  /* update the caller's pointer */
}

uint32_t arr[3] = {50, 60, 70};
uint32_t *q = arr;
increment_ptr(&q);  /* now *q is 60 */

Arrays¶

C arrays are relatively primitive constructs. Keep these three points in mind:

1. Array declarations set aside a contiguous block of memory.

2. An array name is synonymous with the location of the first element.

3. Arrays decay to pointers when used as function parameters or function arguments.

/* avoid */
int i, arr[10];
for (i = 0; i < 10; i++) { /* ... */ }

/* better */
const int ARRAY_SIZE = 10;
int i, a[ARRAY_SIZE];
for (i = 0; i < ARRAY_SIZE; i++) { /* ... */ }

const int N = 100;
int foo[N];
int i;
for (i = 0; i <= N; ++i) {  /* bug: should be i < N */
    foo[i] = 0;
}

C Strings¶

C Strings vs. char Arrays¶

A C string is a char array followed by a null terminator ('\0', ASCII 0). The null terminator is what lets you recover the string length from just a pointer to the start.

char my_str[] = {'e', 'x', 'a', 'm', 'p', 'l', 'e', '\0'};

With double quotes, the null terminator is added automatically:

char *my_str = "example";  /* 7 chars + '\0' */

char arr[] = {'h', 'e', 'l', 'l', 'o'};

<string.h>¶

Common string functions live in <string.h>:

• strlen: count characters before '\0' (does not include the terminator)

• strcpy: copy characters until '\0', including the terminator

A simple sketch of strlen:

int strlen(char s[]) {
    size_t n = 0;
    while (*(s++) != 0) { n++; }
    return n;
}

Here char s[] as a parameter is sugar for char *s.

Use man strlen (or other man pages) to look up library functions.

String Literals¶

Strings created with "..." via a pointer are immutable (read-only):

char *my_immutable_str = "Hello";  /* do not modify */

By contrast, initializing a char array with a string literal creates a mutable copy:

char my_str[] = "hello";  /* can modify my_str[i] */

The difference comes from memory layout: the first points into a read-only data segment, while the second lives on the stack as a writable array.