pointer-arithmetic

Considering you can (can't think of a great way to put it, but) manipulate pointers in Go, is it possible to perform pointer arithmetic like you would in C, say for iterating over an array? I know loops are just fine for that kind of things these days but I'm just curious if it's possible. No. From the Go FAQ : Why is there no pointer arithmetic? Safety. Without pointer arithmetic it's possible to create a language that can never derive an illegal address that succeeds incorrectly. Compiler and hardware technology have advanced to the point where a loop using array indices can be as efficient

Let's consider this example code: struct sso { union { struct { char* ptr; char size_r[8]; } large_str; char short_str[16]; }; const char* get_tag_ptr() const { return short_str+15; } }; In [basic.expr] it is specified that pointer arithmetic is allowed as long as the result points to another element of the array (or past the end of an object or of the last element). Nevertheless it is not specified in this setion what happens if the array is an inactive member of a union. I believe it is not an issue short_str+15 is never UB. Is it right? The following question clearly showes my intent

I've got this piece of code. It appears to dereference a null pointer here, but then bitwise-ANDs the result with unsigned int . I really don't understand the whole part. What is it intended to do? Is this a form of pointer arithmetic? struct hi { long a; int b; long c; }; int main() { struct hi ob={3,4,5}; struct hi *ptr=&ob; int num= (unsigned int) & (((struct hi *)0)->b); printf("%d",num); printf("%d",*(int *)((char *)ptr + (unsigned int) & (((struct hi *)0)->b))); } The output I get is 44. But how does it work? This is not an "and", this is taking the address of the right hand side

Linux's stddef.h defines offsetof() as: #define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER) whereas the Wikipedia article on offsetof() ( http://en.wikipedia.org/wiki/Offsetof ) defines it as: #define offsetof(st, m) \ ((size_t) ( (char *)&((st *)(0))->m - (char *)0 )) Why subtract (char *)0 in the Wikipedia version? Is there any case where that would actually make a difference? The first version converts a pointer into an integer with a cast, which is not portable. The second version is more portable across a wider variety of compilers, because it relies on pointer arithmetic by

It's fairly common knowledge that if you access an element of an array as arr[i] in C that you can also access the element as i[arr] , because these just boil down to *(arr + i) and addition is commutative. My question is why this works for data types larger than char , because sizeof(char) is 1, and to me this should advance the pointer by just one char. Perhaps this example makes it clearer: #include <string.h> #include <stdio.h> struct large { char data[1024]; }; int main( int argc, char * argv[] ) { struct large arr[4]; memset( arr, 0, sizeof( arr ) ); printf( "%lu\n", sizeof( arr ) ); //

How can one portably perform pointer arithmetic with single byte precision? Keep in mind that: char is not 1 byte on all platforms sizeof(void) == 1 is only available as an extension in GCC While some platforms may have pointer deref pointer alignment restrictions, arithmetic may still require a finer granularity than the size of the smallest fundamental POD type Your assumption is flawed - sizeof(char) is defined to be 1 everywhere. From the C99 standard (TC3) , in section 6.5.3.4 ("The sizeof operator"): (paragraph 2) The sizeof operator yields the size (in bytes) of its operand, which may