I have a void pointer and want to access elements from it. How could I transform a void * into an unsigned byte pointer so I can access its elements (which I know are actually unsigned bytes). Thanks
Using C++
+6
A:
You need to cast it to the appropriate type you are using for an "unsigned byte". Once it's casted appropriately, you can access it as if it is an array (access elements).
unsigned char* bytePointer = static_cast<unsigned char*>(originalVoidPointer);
unsigned char elementFive = bytePointer[5];
Reed Copsey
2010-06-08 19:31:32
What's a `byte` ?
Charles Bailey
2010-06-08 19:33:58
There is no type named "byte" in C.
Aviral Dasgupta
2010-06-08 19:34:11
Yes, I am surprised at the two upvotes considering there is no such thing as a 'byte' type in C++.
Ed Swangren
2010-06-08 19:35:18
Th OP said they were "unsigned bytes". Presumably, (s)he has a `typedef char byte;` defined.
Fred Larson
2010-06-08 19:36:35
@Fred: That was my assumption when I wrote this. Clarified my answer.
Reed Copsey
2010-06-08 19:41:02
@Charles, @aviraldg, and @Ed: I was assuming, given the OP's wording, that there was a byte typedef in place. If not, he could of course use unsigned char.
Reed Copsey
2010-06-08 19:43:07
@Fred Larson: Seems like a strange assumption to me considering that C++ has a native type for unsigned bytes called `unsigned char`. And how does `typedef char byte;` magically create an `unsigned byte` type?
Charles Bailey
2010-06-08 19:47:24
If he had cast it to Foo no one would question it. But by using the word byte he's committed some kind of error. Interesting.....
jmucchiello
2010-06-08 19:49:34
@jmucchiello: What's Foo? ;)
Charles Bailey
2010-06-08 19:50:51
Perhaps I'm missing something painfully obvious but I just can't see any way to make `unsigned byte` actual refer to a type or any way to make the syntax `reinterpret_cast<unsigned byte>(originalVoidPointer)` compile. `typedef char byte;` doesn't magically make `unsigned byte` valid a type and a typedef'ed identifier must be one word so you can't `typedef unsigned char unsigned byte`.
Charles Bailey
2010-06-08 19:58:01
OK, you could do `#define byte char` but that's just evil.
Charles Bailey
2010-06-08 20:00:19
I've removed my misplaced upvote, both for `unsigned byte` and for that `reinterpret_cast` (`static_cast` would be correct).
avakar
2010-06-08 20:05:48
@jmucchiello: Read Charles' answer. Additionally, the reasoning is that Java has the byte type.
Aviral Dasgupta
2010-06-08 20:09:23
Reed Copsey
2010-06-08 20:12:25
By the way, I'd avoid that syntax, it's widely known on SO because it's been pointed out several times for general enjoyment, but the average programmer would say that's it's not correct C/C++.
Matteo Italia
2010-06-08 19:36:42
-1, why `reinterpret_cast` with implementation defined results instead of a simple and valid `static_cast`?
avakar
2010-06-08 19:39:22
No, I really meant why the cast for C. Not that the comment is relevant to the question any more.
Charles Bailey
2010-06-08 19:41:17
Without the cast, both in C and in C++, the compiler wouldn't know how to do the pointer arithmetic, since void elements don't have a definite size.
Matteo Italia
2010-06-08 19:45:39
@Matteo: You can convert a `void*` to an `unsigned char*` perfectly well without a case and the original form of this answer didn't have as much context as the C++ only version now does, so it wasn't clear how the suggested cast syntax was to be used.
Charles Bailey
2010-06-08 19:49:23
That cast in C is done implicitly if you are assigning a void pointer to another pointer type, but in this suggestion there's no assignment, and the compiler, without the cast, wouldn't have any clue that it has to interpret the void pointer as a pointer to unsigned char.
Matteo Italia
2010-06-08 19:51:21
@Matteo: As I said, the original form of this answer lacked enough context so it wasn't clear how the suggested cast syntax was to be used.
Charles Bailey
2010-06-08 19:52:52
+1
A:
You typecast. If its is C, then you should use something like:
((unsigned char *) void_ptr)[index];
If its C++, then you shouldn't be using void pointers at all.
Aviral Dasgupta
2010-06-08 19:32:58
I've run into plenty of external libraries (particularly GUI-related) whose APIs require the use of void pointers. 'twould be a shame to never use them in C++ projects.
2010-06-08 19:40:33
... implying that "such" libraries should use pointers to the base type instead.
Aviral Dasgupta
2010-06-08 20:40:18
void pointers still have plenty of uses in C++, especially when performing low level code.
Brian Neal
2010-06-08 20:54:32
I usually write pure C code then, and link against it (with use of extern "C"). But yes, there are *valid* uses of void pointers in C++ code...
Aviral Dasgupta
2010-06-08 21:15:00
+6
A:
// Assuming you have a void* declared:
void* p;
// and it's initialized to point to a valid object (array of bytes)
// somewhere here...
// ...
// You can convert it to a pointer to unsigned char:
unsigned char* bytes = static_cast<unsigned char*>(p);
// ... and access the bytes using []
unsigned char x = bytes[0];
Of course the byte offset you use must be within the size of the object that the void* actually points to.
Charles Bailey
2010-06-08 20:11:32