¿Qué es mejor BOOST_MPL_ASSERT o BOOST_STATIC_ASSERT?

Question

Como recuerdo, una vez fue preferible BOOST_MPL_ASSERT. ¿Esto sigue siendo cierto? Alguien sabe por qué?

Answer 1

[responder a mi propia pregunta]

Depende. Esta es una comparación de manzanas a naranjas. Aunque similares, estas macros NO son intercambiables. Aquí hay un resumen de cómo funciona cada uno:

BOOST_STATIC_ASSERT(P) genera un error de compilación si P != true.

BOOST_MPL_ASSERT((P)) genera un error de compilación si P::type::value != true.

Esta última forma, a pesar de que requiere paréntesis dobles, es especialmente útil debido a que puede generar mensajes de error más informativos si uno utiliza booleanas metafunciones nularia de Boost.MPL o TR1 de <type_traits> como predicados.

Aquí es un programa de ejemplo que muestra cómo utilizar (y abuso) de estos macros:

#include <boost/static_assert.hpp> 
#include <boost/mpl/assert.hpp> 
#include <type_traits> 
using namespace ::boost::mpl; 
using namespace ::std::tr1; 

struct A {}; 
struct Z {}; 

int main() { 
     // boolean predicates 
    BOOST_STATIC_ASSERT(true);   // OK 
    BOOST_STATIC_ASSERT(false);   // assert 
// BOOST_MPL_ASSERT(false);   // syntax error! 
// BOOST_MPL_ASSERT((false));   // syntax error! 
    BOOST_MPL_ASSERT((bool_<true>)); // OK 
    BOOST_MPL_ASSERT((bool_<false>)); // assert 

     // metafunction predicates 
    BOOST_STATIC_ASSERT((is_same< A, A >::type::value));// OK 
    BOOST_STATIC_ASSERT((is_same< A, Z >::type::value));// assert, line 19 
    BOOST_MPL_ASSERT((is_same< A, A >));    // OK 
    BOOST_MPL_ASSERT((is_same< A, Z >));    // assert, line 21 
    return 0; 
} 

Para la comparación, aquí están los mensajes de error que mi compilador (Microsoft Visual C++ 2008) generado por las líneas 19 y 21 arriba:

1>static_assert.cpp(19) : error C2027: use of undefined type 'boost::STATIC_ASSERTION_FAILURE<x>' 
1>  with 
1>  [ 
1>   x=false 
1>  ] 
1>static_assert.cpp(21) : error C2664: 'boost::mpl::assertion_failed' : cannot convert parameter 1 from 'boost::mpl::failed ************std::tr1::is_same<_Ty1,_Ty2>::* ***********' to 'boost::mpl::assert<false>::type' 
1>  with 
1>  [ 
1>   _Ty1=A, 
1>   _Ty2=Z 
1>  ] 
1>  No constructor could take the source type, or constructor overload resolution was ambiguous 

Así que si usted está utilizando metafunciones (como se define here) como predicados continuación BOOST_MPL_ASSERT es tanto menos detallado de código y más informativo cuando se afirma.

Para predicados booleanas simples, BOOST_STATIC_ASSERT es menos detallado de código pesar de que sus mensajes de error pueden ser menos clara (dependiendo de su compilador.)

Answer 2

BOOST_MPL_ASSERT es (aún) generalmente considerado mejor. Los mensajes de este son algo más fáciles de ver (y entiendo, si usa BOOST_MPL_ASSERT_MSG). Hubo algunos comentarios hace unos meses sobre la desaprobación de BOOST_STATIC_ASSERT, aunque creo que todos finalmente estuvieron de acuerdo en que todavía hay espacio para eso en el mundo.