Re: Reference to void
Lucian Radu Teodorescu wrote:
IMHO it's worse to have all kind of exceptions in the language, than to
have one good rule that works in (almost) all cases. In this case, as
you noticed currently "void" isn't really a type, and isn't really a
syntactic placeholder. And the bad thing about this duality is the fact
that we don't know the exact border of this: sometimes void behaves
like a type and we can have pointers to void, and sometimes void
doesn't behave like a type and doesn't allow us to have references of
type void.
Here is an example:
<code>
template <typename T>
struct Test
{
typedef T original_type;
typedef T* pointer_type;
typedef T& reference_type;
};
class A {};
bool b1 = boost::is_same<int, void>::value;
bool b2 = boost::is_same<int, Test<void>::original_type>::value; // (2)
Error here?
bool b3 = boost::is_same<int, Test<A>::original_type>::value;
</code>
Is there something wrong with the definition of the Test class
template? Am I doing something wrong when I try to instantiate
Test<void>, when I need the original type? Why should the creator of
the template have to think of the "void exception" when he is building
his class?
Actually, you can look at the definition of std::allocator - it has
been explicitly specialized for void. I suspect it was a workaround.
Another sort of workaround (adapted from <boost/operators.hpp>):
struct void_t {}; // I have to introduce another empty type
template <class T, class baseT = void_t>
struct incrementable : baseT {
friend T operator++(T& x, int) {
T temp(x);
++x;
return temp;
}
};
The definition of void lacks for generalization, so it couldn't work
well with generic programming. We may expect more flaws as far as
generic programming evolves.
--
Andrei Polushin
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]