When and How the pointer arithmetic evaluate?

Question

I always took pointer arithmetic for granted. But some times it bugs me, what compiler exactly does, and when do they get evaluated? Consider the program below:

#include <stdio.h>
#include <stdlib.h>

int prng(void);

int main()
{
    int x = prng(); // Pseudo Random Generator.

    int (*a)[x];

    a = malloc(sizeof(int) * 2 * x);    // Allocate 2 rows of x columned vectors

    printf("%p %p\n", a, a + 1);    // How and When does a + 1 evaluate ?

    return 0;
}

I am almost certain that the compiler (or program at runtime) won't ask the CPU to add a and 1 like normal integers for evaluating a+1. So how does the compiler (or program) manage to get the correct addresses?

`ptr + n` adds n *steps* to ptr. Each *step* has size `sizeof *ptr`. In your example `a + 1` adds 1 *step* of size `sizeof *a == sizeof (int[x]) == x * sizeof (int)` — pmg, Jun 07 '20 at 07:23
It is evaluated at runtime as well as `sizeof(x)` when `x` is a VLA — Alex Lop., Jun 07 '20 at 07:29
@pmg Does compiler substitute ``x * sizeof (int)`` in the place of ``1`` in ``a+1``? — m0hithreddy, Jun 07 '20 at 07:32
@MohithReddy if you really want to know how the compiler does it, look at the generated assembly output, but you shouldn't care. — Jabberwocky, Jun 07 '20 at 08:14

score 0 · Answer 1 · answered Jun 07 '20 at 09:15

So how does the compiler (or program) manage to get the correct addresses?

a + 1 is evaluated at run time.

At run time, the size of *a is x * sizeof(int).

The sum is formed by adding to a, x ints to it.

Note:

int (*a)[x]; is UB when x <= 0.

a + 1 is UB when allocation fails.

When and How the pointer arithmetic evaluate?

1 Answers1