C++ for Scientists - Technische Universität Dresden

146 CHAPTER 5. META-PROGRAMMING
trans_const.cpp:96: Error: Invalid application of ≫sizeof≪ on incomplete type
≫boost::STATIC_ASSERTION_FAILURE≪
If you see an error message with “STATIC ASSERTION” in it, do not think about the message
itself (it is meaningless) but look at the source code line that caused this error and hope that
the author of the assertion will provide more information in a comment.
When we try to compile our test with the assertion we will see that trans(A) compiles but
not trans(B). The reason is that ‘const dense2D’ is considered different from ‘dense2D’ in
template specialization so that it is still considered non-matrix. The good new is that we do not
need to double our specializations for mutable and constant types but we can write a partial
specialization for all constant arguments:
template
struct is matrix
: is matrix {};
Note that BOOST STATIC ASSERT is a macro and does not understand C ++. This manifests in
particular if the argument contains one or more commas. Than the preprocessor will interpret
this as multiple arguments for the macro and get confused. This confusion can be avoided
by enclosing the argument of BOOST STATIC ASSERT with two enclosing parentheses as we did
in the example (although it was not necessary here). Despite the double parentheses and the
rather arbitrary error message, static assertions are very useful to increase reliabily. The next
C ++ standard will provide static assertions in the language like:
template
class transposed view
{
static assert(is matrix::value, ”transposed view requires a matrix as argument”);
// ...
};
As the reader can see, the integration into the language overcomes the before-mentioned deficiencies
of the macro implementation.
Useful are meta-functions to remove something from a type if exists, e.g. remove const transforms
const T into T and non-constant types remain unchanged. Note that this only removes the
constancy of entire types not that of template arguments, e.g., in vector the constancy
of the arguments is not removed.
Dually, meta-functions can add something to a type:
typedef typename boost::add reference::type ref type;
It would be shorter to just add an & but this is easily overseen in longer type definitions. More
importantly, if some trait returns already a reference then it is an error to add another one. The
meta-function adds the reference only to types that are no references yet. To adding const to a
type we find it more concise without the meta-function:
typedef typename some trait::type const const type;
If the type trait returns already a constant type, the second const will be ignored.
The widest functionality in the area of meta-programming provides the Boost Meta-Programming
Library (MPL) [GA04]. The library implements most of the STL algorithms (§ 4.9) and also