Pointers, arrays and strings in C

Pointers are the topic most feared when learning C. Yet in this course it is something you already know: the address. When you wrote LDR R1, R2, #0 on the LC-3, R2 was a pointer; it held not a value but a memory address. The *p in C is exactly this. This page explains pointers, arrays and strings together, because in C the three are parts of the same idea.

Exam questions: “What is printed?” by drawing a pointer diagram, array and pointer arithmetic, string processing functions, LC-3 memory address calculation.

Address and pointer

Every variable is at a location in memory. The & operator gives the address of that location. A pointer variable is a variable that stores an address.

int x = 42;
int *p = &x;        /* p holds the address of x */
printf("%d %d\n", *p, p == &x);
*p = *p + 8;        /* x = 50 */
printf("%d\n", x);

42 1
50

* is used in two senses: in a declaration (int *p) it means “pointer type”, in an expression (*p) “the value pointed to”.

Pointer diagram

In every question, draw boxes and arrows. Box = variable, arrow = pointer.

int a = 3, b = 7;  int *p = &a, *q = &b;

 p ──► [a: 3]        q ──► [b: 7]

*p = *q + 1;        p ──► [a: 8]        q ──► [b: 7]
q = p;              p ──► [a: 8] ◄── q        [b: 7]
*q = *q * 2;        p ──► [a: 16] ◄── q       [b: 7]

The result: a = 16, b = 7. The line q = p does not copy the value, it copies the arrow.

The LC-3 counterpart

Let x be a local variable (R5 + 0) and p the second local (R5 - 1):

        ADD  R0, R5, #0     ; R0 = &x
        STR  R0, R5, #-1    ; p = &x
        LDR  R1, R5, #-1    ; R1 = p
        LDR  R2, R1, #0     ; R2 = *p

&x is an address calculation (ADD or LEA), *p is an LDR.

“Call by reference” with pointers

In C everything is passed by value. But if the value is an address, the function can change the original variable at that address.

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

int x = 1, y = 2;
swap(&x, &y);           /* x = 2, y = 1 */

This is also the way to return more than one result from a function:

void minmax(int a[], int n, int *mn, int *mx) {
    int i;
    *mn = *mx = a[0];
    for (i = 1; i < n; i++) {
        if (a[i] < *mn) *mn = a[i];
        if (a[i] > *mx) *mx = a[i];
    }
}

int a[5] = {4, -1, 9, 3, 0}, mn, mx;
minmax(a, 5, &mn, &mx);
printf("%d %d\n", mn, mx);

-1 9

The & in the line scanf("%d", &x); is there for this reason: scanf writes the number it reads to the address of x.

Arrays

int a[5]; reserves 5 ints in a row in memory. The index starts at 0: a[0] … a[4].

On the LC-3 (int = one word), if a starts at x4010:

address: x4010  x4011  x4012  x4013  x4014
        [a[0]] [a[1]] [a[2]] [a[3]] [a[4]]

The address of a[i] = base + i. If the array is local it sits on the stack, if global in the global region.

PITFALL · no bounds checking. C does not stop you from writing a[5] or a[-1]; it just reads or overwrites the memory at that address. On the stack this can corrupt another variable or the return address: the classic source of security holes (buffer overflow).

The array name is an address

a is the same as &a[0]. Therefore:

$a[i] \equiv *(a + i) \qquad p[i] \equiv *(p + i)$

Pointer arithmetic: p + k points k elements ahead; the address increases by the size of the type. The difference of two pointers is the number of elements in between.

int a[4] = {7, 3, 9, 1};
int *p;
int s = 0;
for (p = a; p < a + 4; p++)
    s += *p;
printf("%d\n", s);

20

*p++ versus (*p)++

Passing an array to a function

The array is not copied; the address of the first element is passed. void f(int v[]) and void f(int *v) are the same. The function cannot know the size of the array, so the size is given as a separate parameter.

Strings

In C a string is a char array with a null character ('\0', value 0) at the end. The same idea as .STRINGZ on the LC-3.

char s[] = "Hi";
printf("%d %d %d\n", s[0], s[1], s[2]);

72 105 0

Your own string functions

int mylen(const char *s) {
    int n = 0;
    while (s[n] != '\0') n++;
    return n;
}

void mycopy(char *dst, const char *src) {
    while ((*dst++ = *src++) != '\0')
        ;
}

int countc(const char *s, char c) {
    int k = 0;
    for (; *s; s++)
        if (*s == c) k++;
    return k;
}

char d[20];
mycopy(d, "banana");
printf("%s %d\n", d, countc(d, 'a'));

banana 3

PITFALL · comparing strings with ==. a == b compares the addresses of the two arrays. Even if the contents are the same, the addresses differ, and the result is 0. For the contents use strcmp(a, b) == 0.

char a[] = "abc", b[] = "abc";
printf("%d %d\n", a == b, strcmp(a, b) == 0);

0 1

Common mistakes

int x = 5;
int *p = &x;
*p = 9;
printf("%d\n", x);

int a = 3, b = 7;
int *p = &a, *q = &b;
*p = *q + 1;
q = p;
*q = *q * 2;
printf("%d %d\n", a, b);

void swap(int *a, int *b) { int t = *a; *a = *b; *b = t; }
/* in main: */
int x = 1, y = 2;
swap(&x, &y);
printf("%d %d\n", x, y);

int a[5] = {3, 1, 4, 1, 5};
int *p = a;
printf("%d %d %d\n", *(p + 2), p[4], *a + 1);

int a[] = {10, 20, 30};
int *p = a;
int x = *p++;
printf("%d %d %d\n", x, *p, a[0]);

int a[] = {10, 20, 30};
int *p = a;
int x = (*p)++;
printf("%d %d %d\n", x, *p, a[0]);

void dbl(int v[], int n) { int i; for (i = 0; i < n; i++) v[i] *= 2; }
/* in main: */
int v[3] = {1, 2, 3};
dbl(v, 3);
printf("%d %d %d\n", v[0], v[1], v[2]);

char s[] = "hello";
s[0] = 'j';
printf("%s %d %d\n", s, (int) strlen(s), (int) sizeof(s));

char s[] = "hello";
char *p = s + 2;
printf("%s %c\n", p, *(p + 1));

void reverse(char s[]) {
    int i = 0, j = strlen(s) - 1;
    while (i < j) {
        char t = s[i]; s[i] = s[j]; s[j] = t;
        i++; j--;
    }
}
/* in main: */
char w[] = "stack";
reverse(w);
printf("%s\n", w);