c++ - libreria - ¿Qué es mejor BOOST_MPL_ASSERT o BOOST_STATIC_ASSERT?

descargar boost

Question

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

Answer 1

BOOST_MPL_ASSERT es (aún) generalmente considerado mejor. Los mensajes son 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.

Answer 2

[Respondiendo 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 requerir doble paréntesis , es especialmente útil porque puede generar mensajes de error más informativos si se usan las Metafunciones Boolean nullary de Boost.MPL o TR1''s <type_traits> como predicados.

Aquí hay un programa de ejemplo que demuestra cómo usar (y usar mal) estas 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;
}

A modo de comparación, aquí están los mensajes de error que mi compilador (Microsoft Visual C ++ 2008) generó para las líneas 19 y 21 anteriores:

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

Entonces, si usa metafunciones (como se define aquí ) como predicados, entonces BOOST_MPL_ASSERT es menos detallado para el código y más informativo cuando afirma.

Para predicados booleanos simples, BOOST_STATIC_ASSERT es menos detallado para codificar aunque sus mensajes de error pueden ser menos claros (dependiendo de su compilador).