Re: [boost] [type trait extension] I hate volatile...

Subject: Re: [boost] [type trait extension] I hate volatile...
From: Frédéric Bron (frederic.bron_at_[hidden])
Date: 2011-07-22 04:44:01

> What does your code look like that detects void types?  I use the following
> EXPR_IS_VOID macro myself (which is not originally mine, but I think I have
> modified it from the original after some testing); feel free to pilfer.  The
> double comma operator thingy is intended to work even if the type of ( Expr
> ) has an overloaded comma operator, but I've found that GCC has issues with
> this construct, hence the two versions.

Thank you for help. I have tested your code for void detection which
GNUC version gives identical results to the one I use (on msvc, g++
and intel):

namespace detail {\
        struct returns_void_t {};
        static ::boost::type_traits::yes_type returns_void(returns_void_t);\
        static ::boost::type_traits::no_type returns_void(int);\
}
template <typename T> int operator,(const T&, ::detail::returns_void_t);
template <typename T> int operator,(const volatile T&,
::detail::returns_void_t);

#define RETURNS_VOID_IMPL(Expr)\
                sizeof(::boost::type_traits::yes_type)\
                ==\
                sizeof(::detail::returns_void(((Expr), ::detail::returns_void_t())))

Here are the results (best viewed in fixed size font) of void detection with
functions returning various types (int of class X) with various cv qualifiers
and by-value or reference:

                     | g++ | g++ |icpc |msvc |
return type          |4.3.2|4.5.2|10.0 | 10  |
                     |4.3.4|4.5.3|11.1 |     |
                     |4.4.4|4.6.0|12.0 |     |
void                 |  1  |  1  |  1  |  1  |
int                  |  0  |  0  |  0  |  0  |
int const            |  0  |  0  |  0  |  0  |
int volatile         |  1  |  0  |  0  |  0  |
int const volatile   |  1  |  0  |  0  |  0  |
int &                |  0  |  0  |  0  |  0  |
int const &          |  0  |  0  |  0  |  0  |
int volatile &       |  0  |  0  |  0  |  0  |
int const volatile & |  0  |  0  |  0  |  0  |
X                    |  0  |  0  |  0  |  0  |
X const              |  0  |  0  |  0  |  0  |
X volatile           |  1  |  1  |fail |  0  |
X const volatile     |  1  |  1  |fail |  0  |
X &                  |  0  |  0  |  0  |  0  |
X const &            |  0  |  0  |  0  |  0  |
X volatile &         |  0  |  0  |  0  |  0  |
X const volatile &   |  0  |  0  |  0  |  0  |

So only msvc gives the right answer, i.e. detects void returning only when void
returning. g++ from version 4.5 says that any cv qualifiers for by-value int is
ignored which improves the answer for those return types but returning a class
by value with volatile qualifiers fails to complile with intel compiler and
gives the wrong answer with g++. I wonder why the code gives the right answer
withmsvc.

I found another issue with g++ (all versions up to 4.6.0) (works fine
with msvc 10
and intel 12): although g++ behaves well with fundamental types
returned by value,
the result of postfix operator++ applied to an int volatile is detected as void!
The standard states in 13.6/3 (Built-in operators):
"For every pair (T, VQ), where T is an arithmetic type, and VQ is
either volatile
or empty, there exist candidate operator functions of the form
VQ T& operator++(VQ T&);
T operator++(VQ T&, int);"

That means that for an "int volatile" variable the corresponding built-in
operator should be:
int operator++(int volatile &, int);
and according to the table above this should be correctly detected as returning
non-void. Note that prefix operator++ works fine.
This is the program that fails (writes true) with g++ (4.5.2 and 4.6.0):

#include <iostream>
#include <iomanip>
#include <boost/type_traits/detail/yes_no_type.hpp>

namespace detail {\
   struct returns_void_t {};
   static ::boost::type_traits::yes_type returns_void(returns_void_t);\
   static ::boost::type_traits::no_type returns_void(int);\
}
template <typename T> int operator,(const T&, ::detail::returns_void_t);
template <typename T> int operator,(const volatile T&,
::detail::returns_void_t);

#define RETURNS_VOID(Expr)\
   sizeof(::boost::type_traits::yes_type)\
   ==\
   sizeof(::detail::returns_void(((Expr), ::detail::returns_void_t())))

int main() {
   int volatile one_int_volatile;
   std::cout<<std::boolalpha<<"RETURNS_VOID:
"<<(RETURNS_VOID((one_int_volatile++)))<<'\n';
   return 0;
}

Frédéric