Some basic questions about pointers in C and pointer size

Question

In below C code using this online compiler, when I increase the pointer address by one, the actual address increases by four. It is because the data type is int.

#include <stdio.h>

int main()
{
    int my_array[3] = {0, 1, 2};
    int* p_array = my_array;
    
    printf("%p \n", p_array);
    
    p_array = ++p_array;
    
    printf("%p \n", p_array);

    return 0;
}

Output after compilation:

0x7ffeb9ba5814 
0x7ffeb9ba5818

I have two questions:

Is it possible to directly access/point to the single byte at the address 0x7ffeb9ba5815 using pointer? (not by using bitwise operations)
How come the addresses pointers hold in the above case are 6-byte such as 0x7ffeb9ba5818? (I though addresses are either 4 or 8 bytes)

`p_array = ++p_array;` is undefined behaviour. What was your intent here? To increment the pointer? — Konrad Rudolph, Sep 07 '21 at 12:04
`p_array = ++p_array;`: I think your intention was `p_array++;`. Please confirm. — Jabberwocky, Sep 07 '21 at 12:06
@Jabberwocky I think his intention is simply `p_array++;` or `p_array += 1;` — i486, Sep 07 '21 at 12:06
Yes it was my intention. And regarding 6-bytes isnt 0x7ffeb9ba5814 6-bytes? — GNZ, Sep 07 '21 at 12:07
0x7ffeb9ba5818 is a multiple of 4, isn't it (and a multiple of 8 btw)? — Stefan Riedel, Sep 07 '21 at 12:07
@GNZ You have 00 00 for bytes 7 and 8. The address is `0x00007ffeb9ba5814`. — i486, Sep 07 '21 at 12:07
https://stackoverflow.com/questions/949433/why-are-these-constructs-using-pre-and-post-increment-undefined-behavior — William Pursell, Sep 07 '21 at 12:08
Your platform uses 64 bit addresses, therefor the addesses you display are larger than 0xffffffff. — Jabberwocky, Sep 07 '21 at 12:08
If you want to know the size of something, use the `sizeof` operator. — William Pursell, Sep 07 '21 at 12:09
_Why doesnt it show preceeding zeros?_: Because the leading zeros are non significant, and the C standard does not specify the way pointers are displayed with `%p` — Jabberwocky, Sep 07 '21 at 12:10
Wait, why the line `p_array = ++p_array;` is different from `p_array = p_array++;` and `p_array += 1;`? — Hamza Jadid, Sep 07 '21 at 12:10
@HamzaJadid `p_array = ++p_array` is undefined behaviour, read this: https://stackoverflow.com/questions/949433/why-are-these-constructs-using-pre-and-post-increment-undefined-behavior. — Jabberwocky, Sep 07 '21 at 12:13
Does this answer your question? [Why are these constructs using pre and post-increment undefined behavior?](https://stackoverflow.com/questions/949433/why-are-these-constructs-using-pre-and-post-increment-undefined-behavior) — phuclv, Sep 07 '21 at 12:14

altermetax · Answer 1 · 2021-09-07T12:18:45.573

Firstly, I'm assuming you mean ++p_array and not p_array = ++p_array since that's undefined behavior.

Yes, it is. Cast the pointer to type (char*) (or alternatively also (void*) if using GCC) and that pointer will increase and decrease with steps of 1:

int *a = 0;
a++; // a is now 4
char *b = (char*) a;
b++; // b is now 5

They actually are 8 bytes, but the first two bytes are zeros. When printed they get formatted with as few digits as possible, the same way when you write the number 200 you don't write stuff like 0000200.

Konrad Rudolph · Answer 2 · 2021-09-07T12:17:46.893

3

Yes, for example you can cast the address to a pointer-to-char (which in C is a synonym for a byte!) and access that:
```
char *cp = (char *) p_array;
cp++;
printf("%p\n", (void *) cp);
```
They’re not 6 bytes; printing the addresses just omits leading zeros, same as it would print 123 in decimal, not 0…0000000123. In reality, the value of the pointer in the first case would be 0x00007ffeb9ba5814.

edited Sep 07 '21 at 12:17

answered Sep 07 '21 at 12:09

Konrad Rudolph

530,221
131
937
1,214

Will it be 0x00007ffeb9ba5814 or 0x007ffeb9ba5814? Yours is 7-byte now – GNZ Sep 07 '21 at 12:17
@GNZ Yes, I forgot two zeros. – Konrad Rudolph Sep 07 '21 at 12:17

John Bode · Answer 3 · 2021-09-07T14:39:58.097

If you have a pointer to an object of type T, adding 1 to that pointer yields the address of the next object of that type. For example, assume the following declarations:

char *cp  = (char *)  0x8000;
short *sp = (short *) 0x8000;
long *lp  = (long *)  0x8000;

Then the following will all be true:

Address    char           short         long
–––––––    +–––+          +–––+         +–––+
0x8000     |   | cp       |   | sp      |   | lp
           +–––+          + – +         + - +
0x8001     |   | cp + 1   |   |         |   |
           +–––+          +–––+         + - +
0x8002     |   | cp + 2   |   | sp + 1  |   |
           +–––+          + - +         + - +
0x8003     |   | cp + 3   |   |         |   |
           +–––+          +–––+         +–––+
0x8004     |   | cp + 4   |   | sp + 2  |   | lp + 1
           +–––+          + - +         + - +
            ...            ...           ...

Is it possible to directly access/point to the single byte at the address 0x7ffeb9ba5815 using pointer? (not by using bitwise operations)

Yes - cast it to char * or unsigned char *:

unsigned char *ucp = ((unsigned char *) my_array + 1);

How come the addresses pointers hold in the above case are 6-byte such as 0x7ffeb9ba5818? (I though addresses are either 4 or 8 bytes)

The %p conversion specifier just isn't printing any leading 0s - the actual value is 0x00007ffeb9ba5818.

I feel that this answer is a good illustration of the underlying pointer arithmetic. And even though OP seemingly knows about pointer arithmetic, the question shows that their grasp on the concept isn’t that firm, which this answer helps with. — Konrad Rudolph, Sep 07 '21 at 13:22

score 0 · Answer 4 · answered Sep 07 '21 at 15:55

such as 0x7ffeb9ba5818?

This is 48-bit virtual address region. Just below the middle. Like 491 of 1000.

printf("%p %p %p %p %p %p %p\n",
         0, 1, 16, 255, -1, -1L, (1L<<48)/2-1);

prints:

(nil) 0x1 0x10 0xff 0xffffffff 0xffffffffffffffff 0x7fffffffffff

Not only leading zeroes are suppressed! Also 0 itself.

0x7fffffffffff is 140 TB. Virtual.

With the next paging level (5) you will see even less leading zeroes.

Some basic questions about pointers in C and pointer size

4 Answers4