Why can't we use a void* to operate on the object it addresses

Question

I am learning C++ using C++ Primer 5th edition. In particular, i read about void*. There it is written that:

We cannot use a void* to operate on the object it addresses—we don’t know that object’s type, and the type determines what operations we can perform on that object.

void*: Pointer type that can point to any nonconst type. Such pointers may not be dereferenced.

My question is that if we're not allowed to use a void* to operate on the object it addressess then why do we need a void*. Also, i am not sure if the above quoted statement from C++ Primer is technically correct because i am not able to understand what it is conveying. Maybe some examples can help me understand what the author meant when he said that "we cannot use a void* to operate on the object it addresses". So can someone please provide some example to clarify what the author meant and whether he is correct or incorrect in saying the above statement.

Answer 1

My question is that if we're not allowed to use a void* to operate on the object it addressess then why do we need a void*

It's indeed quite rare to need void* in C++. It's more common in C.

But where it's useful is type-erasure. For example, try to store an object of any type in a variable, determining the type at runtime. You'll find that hiding the type becomes essential to achieve that task.

What you may be missing is that it is possible to convert the void* back to the typed pointer afterwards (or in special cases, you can reinterpret as another pointer type), which allows you to operate on the object.

---

Maybe some examples can help me understand what the author meant when he said that "we cannot use a void* to operate on the object it addresses"

Example:

int i;
int*  int_ptr  = &i;
void* void_ptr = &i;
 
*int_ptr = 42;  // OK
*void_ptr = 42; // ill-formed

As the example demonstrates, we cannot modify the pointed int object through the pointer to void.

so since a void* has no size(as written in the answer by PMF)

Their answer is misleading or you've misunderstood. The pointer has a size. But since there is no information about the type of the pointed object, the size of the pointed object is unknown. In a way, that's part of why it can point to an object of any size.

so how can a int* on the right hand side be implicitly converted to a void*

All pointers to objects can implicitly be converted to void* because the language rules say so.

Answer 2

Yes, the author is right.

A pointer of type void* cannot be dereferenced, because it has no size¹. The compiler would not know how much data he needs to get from that address if you try to access it:

void* myData = std::malloc(1000); // Allocate some memory (note that the return type of malloc() is void*)

int value = *myData; // Error, can't dereference
int field = myData->myField; // Error, a void pointer obviously has no fields

The first example fails because the compiler doesn't know how much data to get. We need to tell it the size of the data to get:

int value = *(int*)myData; // Now fine, we have casted the pointer to int*
int value = *(char*)myData; // Fine too, but NOT the same as above!

or, to be more in the C++-world:

int value = *static_cast<int*>(myData);
int value = *static_cast<char*>(myData);

The two examples return a different result, because the first gets an integer (32 bit on most systems) from the target address, while the second only gets a single byte and then moves that to a larger variable.

The reason why the use of void* is sometimes still useful is when the type of data doesn't matter much, like when just copying stuff around. Methods such as memset or memcpy take void* parameters, since they don't care about the actual structure of the data (but they need to be given the size explicitly). When working in C++ (as opposed to C) you'll not use these very often, though.

¹ "No size" applies to the size of the destination object, not the size of the variable containing the pointer. sizeof(void*) is perfectly valid and returns, the size of a pointer variable. This is always equal to any other pointer size, so sizeof(void*)==sizeof(int*)==sizeof(MyClass*) is always true (for 99% of today's compilers at least). The type of the pointer however defines the size of the element it points to. And that is required for the compiler so he knows how much data he needs to get, or, when used with + or -, how much to add or subtract to get the address of the next or previous elements.