pointer-arithmetic

Now we know that doing out-of-bounds-pointer-arithmetic has undefined behavior as described in this SO question . My question is: can we workaround such restriction by casting to std::uintptr_t for arithmetic operations and then cast back to pointer? is that guaranteed to work? For example: char a[5]; auto u = reinterpret_cast<std::uintptr_t>(a) - 1; auto p = reinterpret_cast<char*>(u + 1); // OK? The real world usage is for optimizing offsetted memory access -- instead of p[n + offset] , I want to do offset_p[n] . EDIT To make the question more explicit: Given a base pointer p of a char array

This question already has an answer here: Pointer/Address difference [duplicate] 3 answers i have asked this question in a written test. while running the below code on my lapi, i am getting 10 as output #include<stdio.h> int main() { int *i, *j;/* two pointer variable*/ i = (int *)60; j = (int *)20; printf("%d \n",i-j); return 0; } Output : 10 Can anyone tell me why the output is 10 . According to the C Standard (6.5.6 Additive operators) 9 When two pointers are subtracted, both shall point to elements of the same array object, or one past the last element of the array object; the result is

I was just trying to use a void pointer to an integer array ,I tried to see if i can print the array back by casting it back into int. But it is giving me some random value. Can you tell me where i am going wrong? #include<stdio.h> #include<stdlib.h> int main(){ int a[5]; int x; int j; a[0]=1; a[1]=2; a[2]=3; a[3]=4; void *arr=a; for(j=0;j<4;j++){ x = *(int *)(arr+j); printf("%d",x); } return 0; } Output is this: 133554432131072512 Why is it not pinting elements of array a[] i.e 1,2,3,4 ? You need to cast arr before adding j . Here is a minimal fix: x = *(((int *)arr)+j); but I think it's

I'm preparing some slides for an introductory C class, and I'm trying to present good examples (and motivation) for using pointer arithmetic over array subscripting. A lot of the examples I see in books are fairly equivalent. For example, many books show how to reverse the case of all values in a string, but with the exception of replacing an a[i] with a *p the code is identical. I am looking for a good (and short) example with single-dimensional arrays where pointer arithmetic can produce significantly more elegant code. Any ideas? Getting a pointer again instead of a value: One usually uses

I've known that this is true: x[4] == 4[x] What is the equivalent for multi-dimensional arrays? Is the following true? x[4][3] == 3[x[4]] == 3[4[x]] x[y] is defined as *(x + (y)) x[y][z] would become *(*(x + (y)) + z) x[y[z]] would become *(x + (*(y + (z)))) x[4][3] would become *(*(x + (4)) + 3) would become *(*(x + 4) + 3) 3[x[4]] would become *(3 + (*(x + (4)))) would become *(*(x + 4) + 3) 3[4[x]] would become *(3 + (*(4 + (x)))) would become *(*(x + 4) + 3) Which means they are all equivalent. Yes. In each case x is an array which decays to a pointer and then has pointer arithmetic