Question about void pointers

[raphfrk]

Is this valid?

int a[20];
void *b;

b = (void *)a; // b points to a[0]

b += 5*sizeof(*a); // b points to a[5]

a[5] = 100;

printf( "%d\n" , *((int *)b) ); // prints 100

If so, if a had been a struct, would it still work?

Is there a possibility that the array could contain some padding, so
rather than sizeof, the assignment would be

b += 5*( (void *)(&(a[1])) - (void *)(&(a[0]));

which seems more more complex.

Would any padding be incorporated into sizeof anyway?

[vippstar]

On Sep 16, 6:15 pm, raph...@gmail.c om wrote:

Is this valid?

int a[20];
void *b;

b = (void *)a; // b points to a[0]

No need for the cast.

b += 5*sizeof(*a); // b points to a[5]

No, it's not valid. you can not perform arithmetic operations on void
* pointers.
If it compiles, it's because you have extensions enabled. Extensions
are topical to the newsgroup dedicated to the compiler that makes use
of them.
Assuming you had something like

b = ((unsigned char *)b) + 5 * sizeof *a;

Yes, that would be ok.

a[5] = 100;

printf( "%d\n" , *((int *)b) ); // prints 100

Yes, that is valid. Assuming you use my fixes.

If so, if a had been a struct, would it still work?

Yes, but by using the offsetof() macro in <stddef.h>

Is there a possibility that the array could contain some padding, so
rather than sizeof, the assignment would be

No. Arrays don't have padding bytes.

b += 5*( (void *)(&(a[1])) - (void *)(&(a[0]));

which seems more more complex.

Would any padding be incorporated into sizeof anyway?

Yes, sizeof reports the size of an object. Padding bits & bytes belong
to the size of the object.

if sizeof (unsigned int) == 4 and CHAR_BIT == 8, it doesn't mean
unsigned int has 32 value bits.
It might have 16 or less padding bits. (but not more, because of the
guarantee that UINT_MAX >= 65535)

[sh.vipin]

On Sep 16, 8:15*pm, raph...@gmail.c om wrote:

Is this valid?

int a[20];
void *b;

b = (void *)a; *// b points to a[0]

b += 5*sizeof(*a); // b points to a[5]

a[5] = 100;

printf( "%d\n" , *((int *)b) ); // prints 100

If so, if a had been a struct, would it still work?

Is there a possibility that the array could contain some padding, so
rather than sizeof, the assignment would be

b += 5*( (void *)(&(a[1])) - (void *)(&(a[0]));

which seems more more complex.

Would any padding be incorporated into sizeof anyway?

b += 5*sizeof(*a); // b points to a[5]
is *incorrect*

when you do
--char *c; c++; ==c is incremented by 1
--long int *x; x++ ==x is incremented by 4.
--void *p; p++ //incorrect ==because compiler doesn't know by what
amount should it increase.

the number by which a pointer value is incremented or decremented is
dependent on type of object pointer is pointing to. This number has a
specific name which i don't remember, but this thing is not defined
for void *

b += 5*( (void *)(&(a[1])) - (void *)(&(a[0]));
here also "+=" operation will be invalid due to pointer
moreover there is no padding in between the arrays.

--
vIpIn

[vippstar]

On Sep 16, 7:13 pm, sh.vi...@gmail. com wrote:

when you do
--char *c; c++; ==c is incremented by 1
--long int *x; x++ ==x is incremented by 4.

Wrong, assuming x was initialized, it would be incremented by 1.

Here's proof:

long int i[1], *p = i, *q = &i[1];
printf("%d\n", (int)(q - p));

Will always print 1.

[Ben Pfaff]

ra*****@gmail.c om writes:

int a[20];
void *b;

b = (void *)a; // b points to a[0]

b += 5*sizeof(*a); // b points to a[5]

This is incorrect, but it will work if you are using GCC in its
default mode, because GCC assumes that "void" has size 1 for the
purpose of pointer arithmetic. If you want to write code that
conforms to the ANSI C standard, you should give GCC appropriate
options to turn off this feature (-Wpointer-arith or -pedantic).
--
Ben Pfaff
http://benpfaff.org

[Richard]

vi******@gmail. com writes:

On Sep 16, 7:13 pm, sh.vi...@gmail. com wrote:

>when you do
--char *c; c++; ==c is incremented by 1
--long int *x; x++ ==x is incremented by 4.

Wrong, assuming x was initialized, it would be incremented by 1.

Even if it wasnt initialised it would be incremented by something.

>
Here's proof:

Proof of nothing. You are, again, being purposely difficult.

>
long int i[1], *p = i, *q = &i[1];
printf("%d\n", (int)(q - p));

Will always print 1.

And the following:

int main() {
long int i[1], *p = i, *q = &i[1];
printf("%u\n",p ++);
printf("%u\n",p ++);
printf("%u\n", (int)(p - q));

}

The first printf gives me:

3214862936

And the second:

3214862940

Now, that is 4. On my machine.

[Keith Thompson]

sh******@gmail. com writes:

On Sep 16, 8:15*pm, raph...@gmail.c om wrote:

>Is this valid?

int a[20];
void *b;

[...]

>
b += 5*sizeof(*a); // b points to a[5]
is *incorrect*

Yes.

when you do
--char *c; c++; ==c is incremented by 1
--long int *x; x++ ==x is incremented by 4.
--void *p; p++ //incorrect ==because compiler doesn't know by what
amount should it increase.

the number by which a pointer value is incremented or decremented is
dependent on type of object pointer is pointing to. This number has a
specific name which i don't remember, but this thing is not defined
for void *

You're probably thinking of "stride", though the standard doesn't use
that term.

However, some compilers (particularly gcc) allow arithmetic on void*
as an extension, treating the stride as 1 byte. In my opinion this
extension is a bad idea; it can be convenient, but it doesn't give you
anything you can't do by other means, it has some bizarre
consequences, and as we've seen here it can make it easy to write
non-portable code without realizing it.

If you invoke gcc with the right options (something like "-ansi
-pedantic -Wall -Wextra") it will at least warn you about any attempts
to use this extension.

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
Nokia
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"

[raphfrk]

On Sep 16, 4:20 pm, vipps...@gmail. com wrote:

b = ((unsigned char *)b) + 5 * sizeof *a;

I see, got to switch to char * so that it can be incremented properly.

Yes, but by using the offsetof() macro in <stddef.h>

I meant to point to the structure.

struct st { int val; } a[100];

void *b;

a[5].val = 100;

b = a;
b = ((unsigned char *)b) + 5 * sizeof *a;

printf( "%d\n" , b->val );

[raphfrk]

On Sep 16, 5:51 pm, raph...@gmail.c om wrote:

On Sep 16, 4:20 pm, vipps...@gmail. com wrote:

b = ((unsigned char *)b) + 5 * sizeof *a;

I see, got to switch to char * so that it can be incremented properly.

Yes, but by using the offsetof() macro in <stddef.h>

I meant to point to the structure.

struct st { int val; } a[100];

void *b;

a[5].val = 100;

b = a;
b = ((unsigned char *)b) + 5 * sizeof *a;

printf( "%d\n" , b->val );

or at least

printf( "%d\n" , ((struct st *)b)->val );

[s0suk3]

On Sep 16, 11:51*am, ra*****@gmail.c om wrote:

On Sep 16, 4:20 pm, vipps...@gmail. com wrote:

>b = ((unsigned char *)b) + 5 * sizeof *a;

I see, got to switch to char * so that it can be incremented properly.

No, to unsigned char *. But if your compiler can do it with the void
*, then do it with the void *. It's probably specialized for that kind
of stuff anyway.

Sebastian