Extracting an int out of void* - c++

Question

I have a method that returns void* and it is basically some block of data from allocated shared memory on linux.
The first 4 bytes in that data are an int and I haven't managed to extract that int.
These are the methods what I have tried:
int getNum(void* data)
{
return *(int*)data; // 1
return *(int*)(data & 0xFFFFFFFF); // 2
}
Thanks in advance!

Answer 1

int getNum(void* data)
{
return *(int32_t*)data; // 1
// ^^^^^^^
}
Should work.
Also if you need to worry about unaligned addresses achieved from the void*, you may use #Martin Bonner's suggestion:
int getNum(void* data)
{
int32_t result;
memcpy(&result, data, sizeof(int32_t));
return result;
}

Answer 2

int getNum(void* data)
{
return *(int*)data; // 1
return *(int*)(data & 0xFFFFFFFF); // 2
}
The second method won't even compile; data is a pointer, and you cannot apply the & bitwise and operator to a pointer value. (I don't know why you'd even want to mask a pointer value like that. If it were legal, the mask would do nothing on a 32-bit system, and would probably destroy the pointer value on a 64-bit system.)
As for the first, it should work -- if data is a valid pointer pointing to a properly aligned int object.
If that's failing at run time with a segmentation fault, it probably means either that data is null or otherwise not a valid pointer (in that case you can't do what you're trying to do), or it points to a misaligned address (which won't cause a seg fault if you're on an x86 or x86_64 system; are you?).
To find out what the pointer looks like, try adding this:
printf("data = %p\n", data);
to your getNum function -- or examine the value of data in a debugger.
If alignment is the problem, then you can do this:
int result;
memcpy(&result, data, sizeof result);
return result;
But in that case storing an int value as a misaligned address is an odd thing to do in the first place. It's not necessarily wrong, just a very odd thing to do.
How is the memory that data points to allocated?

Answer 3

Assuming the int is 4 bytes long, and you're operating on Linux, your method will work. If you want a portable method to move ints in pointers, try the open source ptrint module from CCAN. It converts a pointer to int by adding NULL to the int. It converts in the other direction by subtracting NULL, returning a ptrdiff_t.
#include <assert.h>
#include <stdio.h>
int getNum(void* data)
{
return *(int *) data;
}
char buf[16];
int main(void)
{
assert(sizeof(int) == 4);
*(int *)buf = 9;
printf("%c%c%c%c\n", buf[0], buf[1], buf[2], buf[3]);
printf("%d\n", getNum((void *) buf));
return 0;
}
// $ ./foo | cat -tv
// ^I^#^#^#
// 9