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).