Pointers exercises

Maria A. Hernandez Rivero

All examples are based on a 64-bit system

First example

Recall the pointer arithmetic formula: base + offset * size . Where base is the initial memory address.
Let's declare an array of four long - recall that in a 64-bit system, each long is 8 bytes (16 hexadecimal digits). Thus, the following array will occupy 32 bytes in memory.

long array[] = {0xbeefdeabdeadbeef, 2, 3, 4};

The first number is written in hexadecimal representation. The other 3 are written in decimal representation. Also, recall that array is just an alias for a memory address.

array will interpret the bytes in memory like this:

Second example

Let's declare an array of unsigned long

unsigned long array2[] = {4294967295, 250, 3, 4};

The maximum number that can be represented with an unsigned integer is 232 - 1 = 4294967295.
Thus, 4294967295 = 1111_1111_1111_1111_1111_1111_1111_1111 == 0xffff_ffff.
In other words, if we print array2[0] as an hexadecimal we will get 0xffffffff . Interpreted as a long 4294967295 is: 0000_0000_0000_0000_0000_0000_0000_0000_1111_1111_1111_1111_1111_1111_1111_1111 (upper 32 bits (4 bytes) are all zero and lower 32 bits are all 1).

array2 will interpret the bytes stored in memory like this:

Third example

Let's declare an array similar to the array above, but now the first element of the array will be 4294967296

long array3[] = {4294967296, 250, 3, 4};

When interpreted as a long,
4294967296 = 0000_0000_0000_0000_0000_0000_0000_0001_0000_0000_0000_0000_0000_0000_0000_0000 Notice that the first 4 bytes are all zeroes. Thus, the following print statement printf("0x%04x\n", *pi3); outputs 0x0000 . NOTE: These 4 zeroes do not represent 4 bytes, each byte is represented by two hexadecimal digits. We get 4 zeroes in the output because we specified it in the formatting.

array3 will interpret the bytes stored in memory like this:

Fourth example

Let's declare an array of four long:

long array4[] = {0xbeefdeabdeadbeef, 2, 3, 4};

Now, let's reinterpret the memory address where array4 is stored as a pointer to a char, and assign this address to the pointer pc

char *pc = (char *)array4;

pc will interpret the bytes in memory as follow:

Fifth example

In the following statement, we are typecasting 1000 to a pointer to integer:

int *z = (int *)1000;

This simply means treat 1000 as a memory address. It also means that z will treat memory addresses as follow:

Sixth example

In the following statement, we are typecasting 1000 to a pointer to pointer:

char **pointer_to_pointer = (char **)1000;

This simply means treat 1000 as a memory address. It also means that pointer_to_pointer will treat memory addresses as follow:

Seventh example

First part

Let's declare the following 2D array:

short matrix[4][2] = {{0x1234,0x5678},{0x9012,0xabcd},{0xdf01,0xfedc},{0xba21,0x9876}};

Recall that elements are stored contiguously in memory and the smallest addressable unit of memory is one byte - each memory cell stores 1 byte. Thus, a visual representation of the memory layout of the previous 2D array is something like this:

Second part

Now, after performing the following typecasting:

unsigned char* cp = (unsigned char *)matrix;

cp will interpret the bytes in memory as follow: