91
votes

The description of std::is_void states that:

Provides the member constant value that is equal to true, if T is the type void, const void, volatile void, or const volatile void.

Then what could be const void, or a volatile void ?

This answer states that const void return type would be invalid (however compiles on VC++ 2015)

const void foo() { }

If by standard, const void is invalid (VC being wrong) - then what is const void?

3
The answer you link to doesn't state that it would be invalid, it states that it would be "meaningless", which I would take to mean "doesn't offer any benefits over void without const". - user743382
@hvd, the answer states that compiler should warn/error about such qualification. By that I presume C++ standard doesn't allow qualifications with void - Ajay
The answer states that the compiler should warn about such qualification, it doesn't mention an error, and an error would be wrong. That remark is just about quality of implementation, not about conformance, but I can understand that that's not at all clear from the remark itself. - user743382
@Ajay the standard doesn't specify that there should be a warning when you use meaningless code. It was a decision by gcc to give you an additional hint that this code doesn't do anything. But VC isn't wrong in any way. - AliciaBytes
@Ajay The answer states that clang gives a warning, and that, in the author's opinion, other compilers should. If the standard didn't allow it, it would be an error, not a warning. - molbdnilo

3 Answers

94
votes

const void is a type which you can form a pointer to. It's similar to a normal void pointer, but conversions work differently. For example, a const int* cannot be implicitly converted to a void*, but it can be implicitly converted to a const void*. Likewise, if you have a const void* you cannot static_cast it to an int*, but you can static_cast it to a const int*.

const int i = 10;
void* vp = &i;                           // error
const void* cvp = &i;                    // ok
auto ip = static_cast<int*>(cvp);        // error
auto cip = static_cast<const int*>(cvp); // ok
24
votes

As void, const void is a void type. However, if const void is a return type, the const is meaningless (albeit legal!), because [expr]/6:

If a prvalue initially has the type “cv T”, where T is a cv-unqualified non-class, non-array type, the type of the expression is adjusted to T prior to any further analysis.

However, it is a valid type itself and occurs in e.g. C-standard library functions, where it's used to ensure const-correctness of argument pointers: int const* cannot be converted to void*, but void const*.

18
votes

Types can be the result of templates; a template might state const T, and be instantiated with T as void.

The linked answer is misled, or rather, limited in view in that it regards the special case of a non-template type, and even then const void might be meaningless, but it is valid code.