On Monday, 5 December 2022 at 08:21:44 UTC, bauss wrote:
Because it's much easier to work with.
Ex. if you have an array of 4 signed 32 bit integers that
you're pointing to then you can simply just increment the
pointer by 1.
If it was raw bytes then you'd have to increment the pointer by
4 to move to the next element.
This is counter-intuitive if you're moving to the next element
in a loop ex.
This is how you'd do it idiomatically:
```d
foreach (i; 0 .. list.length)
{
(*cast(int*)(ptr + i)) = i;
}
```
Is this `(*cast(int*)(ptr + i)) = i;` or you did a mistake and
wanted to write: `(*cast(int*)ptr + i) = i;`? Cause like we said
before, the first operand must be a cast to the type for this to
work right.
Compared to:
```d
foreach (i; 0 .. list.length)
{
(*cast(int*)(ptr + (i * 4))) = i;
}
```
Got it! I guess they could also just allow us to use bracket
notation to do the same thing. So something like:
```d
foreach (i; 0 .. list.length) {
(cast(int*)ptr[i]) = i;
}
```
This is what happens with arrays anyways. And arrays ARE pointers
to a contiguous memory block anyways so they could do the same
with regular pointers. The example also looks more readable.
