views:

586

answers:

8

In Visual Studio C++ version 9 (and probably other versions too), the following code:

int a = sizeof(void);
void const *b = static_cast<void const *>("hello world");
b += 6;

Generates these errors:

error C2070: 'void': illegal sizeof operand
error C2036: 'const void *' : unknown size

This code works under GCC, which treats sizeof(void) as 1.

Is there some way around this limitation, as casting explicitly to char * for purposes of pointer arithmetic adds to the confusion (void * is well recognised and used as a typeless pointer to raw memory).

Update0

  • Please note, I'm well aware of the existence of the standard.
  • I want to do raw pointer arithmetic.
  • I take sizeof(void) to show that I'm well aware the fact that it isn't 1 is the cause of the problem.
  • The code example is simply to demonstrate what is required to generate the errors.
  • I know this isn't a "normal" way to use void, but this is C, and these things happen.
  • Yes, people need to do this at low-level. I'm not after why, I'm after how. If you want to know why, take a look at some kernel source, or your friendly glibc.

Update1

It seems this question has generated a great deal of confusion. The question is not about why having sizeof(void) == 1 is not standard, but what to do when it isn't.

In the instance that single-byte pointer arithmetic is to be done, it turns out that casting to char * is the correct answer, not because *(void *) has no size, but because the standard actually guarantees that *(char *) is always 1. Therefore the use of char * is always correct, and congruent with void * with the GCC extension for the purposes of raw pointer arithmetic.

To further reinforce the point, void * is the correct choice for pointers to typeless memory, and char * is the correct type to cast to for raw pointer arithmetic.

+1  A: 

I can see the error on the first line at least - you have sizeof(void) and it should be sizeof(void*), no?

Chris
No. I do mean void.
Matt Joiner
`sizeof void` is meaningless. Change your approach.
GMan
+12  A: 

Incrementing a pointer is technically supposed to increment it by whatever size of thing that its pointing at. Void points at nothing, so the size is unknown.

Its a nicety for some compilers to let you increment void pointers.

Casting is annoying, because you have to either cast it to another pointer, and then back, or do something awkward like (*(char *)&voidptr) += 6

Personally, I'd just declare it as a char * for purposes of arithmetic

Matthias Wandel
Managu
Managu is right. Yet, this would be an act or raw *reinterpretation* of `void *` pointer as a `char *` pointer. Reinterpretation is always a bad idea. Better use a *conversion* as in `voidptr = (char *) voidptr + 6`.
AndreyT
I've been implementing a linked list using void pointers. When the list is created it is passed a `size_t data_size` so it can perform copying operations etc. Now I've come to the problem of creating a list-to-array conversion routine. The intuitive (for me) thing to do was to add `data_size` to the void pointer to move it to the next item in the array... Never mind. I've upvoted this question because it has proven useful.
James Morris
+7  A: 

In C language sizeof cannot be applied to incomplete types. void is an incomplete type, which is why you can't use it as operand of sizeof.

Pointer arithmetic of void * pointers is also not supported in C. In order to be used with pointer arithmetic the pointer has to point to object type, which void is not.

GCC allows both as a weird language extension.

AndreyT
Strangely enough it is not considered an error in _paranoid mode_ unless either `-Werror` or `-pedantic-errors` is specified. I just came across exactly the same conclusion when I took a look at the Standard.
D.Shawley
+4  A: 

void * is meant to imply "pointer to unknown"

Adding 6 to a void pointer is therefore undefined, because you're asking the compiler to advance the pointer by "the size of 6 unknown objects".

You should not be doing it.

Shmoopty
+1  A: 

For purely pointing at raw data and incrementing that pointer by the number of bytes a chunk of data occupies, I always use char *. I then recast the pointer to a relevant data structure pointer once I need to treat it as something specific. Incrementing a void * isn't portable among compilers.

Jim Buck
A: 

It would appear the correct answer is to use char * for pointer arithmetic, because sizeof(char) is always defined to be 1, and to be of the finest addressable granularity on any platform.

So in short, there is no way around the limitation, char * is in fact the proper way to do it.

Matthias Wandel had the right answer but with a different justification.

Matt Joiner
Your question was not about what would be the correct type for pointer arithmetic. Your question was about why MSVC spat an error for `sizeof( void )` and if there is "any way around this limitation" (which there is not, as Matthias and others pointed out correctly). Including some strong words towards people trying to be helpful. Be a man and accept another's answer instead of complaining how the correct answer didn't fit your broken question...
DevSolar
...and a week later, there's your "accepted" answer rated -2, while the answer you claim has not the correct "justification" is rated 11...
DevSolar
i'm not changing it. i know what i meant, and i knew the answer when i saw it. "is there a way around this limitation?": "no, and here's why". if someone makes a more accurate answer, i'll be happy to change. Matthias' answer is quite correct, but not what i was after.
Matt Joiner
**There is no limitation.**
DevSolar
A: 

There are two different questions here. The first is for void, and the second for void*. They are different types, and have little in common beside the name.

void is used mainly for function declarations/definitions (as the return type or to mean "takes no arguments"). You can't ever possibly have an object of type void. Ever. So it's hard to see a need to find out the size of that nonexistent object. GCC's behavior is nonstandard, and an intentional extension. However, I believe they chose sizeof(void) == 1 because the C++ standard requires every object to take at least one byte of space.

void* means "pointer to real data, but without the relevant type information." It is entirely possible to have void*; and you will run into them, a lot. However, because the type information is ignored you can't manipulate the pointer much. This is by design, because if you don't know what you have you really don't know what you can do with it.

But if you want to treat the memory as a collection of bytes then char* does that. A char is one byte, everywhere. A string of bytes is a char*. If you find this weird, use byte* (where you define byte as something like unsigned char).

Max Lybbert
No, GCC giving an answer of 1 is an implementation detail. `void` is an incomplete type, and as such it should not be possible to take the size of it. GCC is in error, here.
GMan
Maybe I should have been clearer. GCC's behavior is an intentional extension ( http://gcc.gnu.org/onlinedocs/gcc-4.1.2/gcc/Pointer-Arith.html ), and I believe they picked a size of 1 because the C++ standard requires any object to take up at least one byte.
Max Lybbert
Edited response.
Max Lybbert
A: 

void * is well recognised and used as a typeless pointer to raw memory.

Correct. Not having a type means not having a size either.

DevSolar
now what about the actual question?
Matt Joiner
What about it? You apparently finally accepted that sizeof( void ) is nonsense because void does not have a size, about the same time you posted the above comment.
DevSolar