Boost logo

Boost :

From: Gennaro Prota (gennaro_prota_at_[hidden])
Date: 2004-05-22 03:25:03

On Sun, 16 May 2004 10:40:52 -0400, David Abrahams
<dave_at_[hidden]> wrote:

>So, should I just remove it?

Well, not because it isn't implementable. Admittedly, it isn't the
most useful thing in the world either, so I don't have a strong
opinion about its inclusion ;)

>Looking back at that thread, I'm
>surprised I included it in this header because I don't think I ever
>really understood what you were saying.
>I don't think there's an alternative to using the comma operator that
>will work both when dst_type is a dependent type in a template and
>when it is not dependent, because of differences in the need for

Good point. Then we could attack the expression part of static_cast.
What about using the conditional operator? I don't know how that
interacts with broken compilers, though. If you like it, I could
provide the tests.


#include <cstddef>

namespace boost {

template< typename T>
struct identity
    typedef T type;

// The use of identity creates a non-deduced form, so that the
// explicit template argument must be supplied
template <typename T>
inline T implicit_cast (typename identity<T>::type x) {
    return x;

} // namespace boost

// Macro for when you need a constant expression.
// Note that 'expr' appears three times but is
// evaluated (at most) once.
#define BOOST_IMPLICIT_CAST(dest_type, expr) \
  (static_cast<dest_type>( \
                 sizeof(boost::implicit_cast<dest_type>(expr)) ? \
                 (expr) : (expr) \
                ) \

// Examples:

template <typename T>
struct X
    typedef T type;

// integral constant expressions
template <typename T>
void f(T arg) {

 // dest_type is dependent
 int x [ BOOST_IMPLICIT_CAST(typename X<T>::type, 'A') ];
 // dest_type is non-dependent
 int y [ BOOST_IMPLICIT_CAST(int, 'B') ];


// constant-expressions for the purpose of non-local static object

// (a) null pointer value (of type char*)
static void * pc = BOOST_IMPLICIT_CAST(void*, (char*)(0) );

// (b) null member pointer value
struct X2 { void f(int) {} };
static void (X2::*pm)(int) = BOOST_IMPLICIT_CAST( void (X2::*)(int),

// (c) arithmetic constant expression
static int n = BOOST_IMPLICIT_CAST(int, 1.0);

// (d) address constant expression
static const void * pso = BOOST_IMPLICIT_CAST(const void*, (const
char*) (1 +

// (e) reference constant expression
static char c = 'x';
static int n2 = BOOST_IMPLICIT_CAST(int, c);

// these should fail

struct B {};
struct D : B {};
D d;
B & ref = d;

enum my_enum { value1, value2 };

void g()
  BOOST_IMPLICIT_CAST(my_enum, 1);


int main()


Boost list run by bdawes at, gregod at, cpdaniel at, john at