What is const void?

Question

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?

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`". — , Jun 17 '16 at 12:13
@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, Jun 17 '16 at 12:18
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. — , Jun 17 '16 at 12:20
@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, Jun 17 '16 at 12:22
@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, Jun 17 '16 at 12:25

Benjamin Lindley · Accepted Answer · 2016-06-17T12:21:57.057

98

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

edited Jun 17 '16 at 12:21

answered Jun 17 '16 at 12:16

Benjamin Lindley

101,917
9
204
274

4

While your answer is good, it doesn't state the reason of `const void`, but its all around void and non-void pointers [ with (non-)const-ness ]. – Ajay Jun 17 '16 at 12:27
26

@Ajay: I disagree. A `const void*` is the only reason you would ever see `const void`. It might be passed around as a template argument, but that argument type will only ever be instantiated with a `*` at the end of it. – Benjamin Lindley Jun 17 '16 at 12:30
@BenjaminLindley You may also see `const void` in [question asked by language lawyer](http://stackoverflow.com/questions/37312668) – cpplearner Jun 17 '16 at 14:51
3

@Ajay: At some point this question becomes a philosophy question. The "reason" of `const void` is that all types in C++ can be made `const`. It "exists" in the same way that `void` exists. @Benjamin Lindley's answer explains what it is by way of when you see it and how you use it. – Chris Beck Jun 18 '16 at 19:34

Columbo · Answer 2 · 2016-06-17T12:30:01.360

23

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*.

edited Jun 17 '16 at 12:30

answered Jun 17 '16 at 12:22

Columbo

60,038
8
155
203

`const void` as a return type does affect the function type, so it's not completely meaningless. – cpplearner Jun 17 '16 at 14:46
1

@cpplearner Except it is in every practical sense, because neither the *signature* of the function nor the type of a call to it are affected. – Columbo Jun 17 '16 at 14:50
Well it can change the signature of a function template. +1 nonetheless – cpplearner Jun 17 '16 at 14:53
@cpplearner Fair enough - it still is a waste of keystrokes, though. – Columbo Jun 17 '16 at 14:55
We normally see: const int * cannot go to void *, but const void *. – mgouin Feb 28 '19 at 21:11

DevSolar · Answer 3 · 2016-06-17T12:21:35.767

18

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.

edited Jun 17 '16 at 12:21

answered Jun 17 '16 at 12:16

DevSolar

67,862
21
134
209

What is const void?

3 Answers3

Linked