C++ metaprogramming

Arindam Mukherjee
Pune C++ and Boost Meetup
C++TEMPLATE METAPROGRAMMING

Template type computations
 Templates provide a Turing complete
computation subsystem – that runs during
compilation.
 This capability was not entirely consciously
designed.
 Erwin Unruh found this somewhat
accidentally ~ early 90s.

Templates
 Compile time entities completely evaluated
by the compiler, based on arguments passed.
std::vector<int> nums; // std::vector<int> unrelated
std::vector<std::string> names; // to std::vector<std::string>
template <typenameT> class Foo; // declaration
template <typenameT> class Foo { … }; // definition
Foo<int> foonum; // Foo<int> is specialization

Non-type template parameters
 Templates can have non-type parameters:
template <typename T, int N>
struct array {
T data[N];
….
}
 Non-type args are compile time constants.
array<int, 10> arr; // array of 10 ints
 sizeof is evaluated at compile time.
int arr[sizeof(int)]; // array of 4* ints

Embedded types
 Typedefs inside a class / class template.
template <typename T>
struct add_const {
typedef const T type;
};
add_const<int>::type ci; // const int

Embedded constants
 Enums inside a class / class template.
template <int M, int N> struct add {
enum { value = M + N }
}
int array[add<10, 20>::value];

Branching: specializations
 Specialize for specific types.
struct Foo { … }; // default impl
template <>
struct Foo<int> { … }; // int-specific
 Applicable to function templates too.

Partial specializations
 Specialize for type families.
template <typename T, typename U>
struct Foo { … }; // default impl
struct Foo<T, T> { … }; // Foo<char, char>
struct Foo<T*, T> { … }; // Foo<int*, int>
 NOT applicable to function templates.

Recursion by specializations
 Compute factorial at compile time:
template <int N> struct factorial {
enum { value = N*factorial<N-1>::value };
};
template <> struct factorial<0> { //
terminating condition
enum { value = 1 };
};

Applying the techniques
 Remove const:
template <typename T> struct remove_const
{ typedef T type; };
template <typename T> // partial
struct remove_const<const T> { // speclzn
typedef T type;
};
 Called as:
remove_const<const int>::type x; // int

 Querying types:
struct are_same
{ enum { value = 0 }; };
template <typename T> / partial
struct are_same<T, T> // specialization
{ enum { value = 1 }; };
 Called as:
are_same<int, int>::value == 1;

 Remove levels of indirection:
struct deref
{ typedef T type; };
template <typename T> // partial
struct deref<T*> { // specialization
typedef typename deref<T>::type type;
}
 Called as:
deref<int*****>::type x; // x is int

Boost Type Traits
 A header-only library to query and
manipulate types at compile time.
 Lots of trait metafunctions.
#include <boost/type_traits.hpp>
typedef int* intptr;
assert(boost::is_ptr<intptr>::value);
struct Foo {int a; void *b; float c; };
assert(boost::is_pod<Foo>::value);

SFINAE
 Compiler tries to resolve function calls to a
unique overload, or unique template with
appropriate arguments.
 Multiple templates may be candidates but a
unique one must survive.
 All candidates instantiated.
 Those that fail instantiation eliminated. Not
An Error if a single candidate survives.

SFINAE & enable_if
 Exploit SFINAE to resolve to apt template.
 boost::enable_if
#include <boost/utility/enable_if.hpp>
boost::enable_if<true, T>::type x; // T
boost::enable_if<false, T>::type y; //!def
 boost::disable_if (opposite of enable_if).

SFINAE & enable_if (contd.)
 Serialize arbitrary types:
#include <boost/utility/enable_if.hpp>
typedef vector<char> buffer_t;
buffer_t serialize(const T&);
 Need a fast version for POD types and
generic version for non-POD types.
enable_if<is_pod<T>, vector<char>>::type
serialize(const T&) {…} // pod version
// Use disable_if for the non-POD version

Metafunctions
 Metafunction: a class or class template taking
only type parameters, with a single
embedded typedef.
 All the Boost type traits are metafunctions.
 Boost TMP Library: library of metafunctions.
 Provides means of composing and generating
metafunctions from simpler metafunctions.

Composing metafunctions
 Metafunctions need to be combined:
template <typename T> void foo(T obj) {
if (boost::is_pointer<T>::value ||
boost::is_array<T>::value) //runtime
{ … }
else { … }
}

Boost MPL (contd.)
 How to make another metafunction that OR’s
two type traits.
#include <boost/mpl/or.hpp>
template <typename T> void foo(T obj) {
if (boost::mpl::or_<
boost::is_pointer<T>
, boost::is_array<T>
>::value)
{ … }
else { … }
}

Boost MPL (contd.)
 Numbers can be wrapped in types:
#include <boost/mpl/integral_c.hpp>
#include <boost/mpl/greater.hpp>
namespace mpl = boost::mpl;
struct is_larger : mpl::greater<
mpl::integral_c<size_t, sizeof T>
, mpl::integral_c<size_t, sizeof U>
>
{};

Thank you!
 Q & A
 Book: Modern C++ Design – Andrei
Alexandrescu
 Book: Advanced C++ Template
Metaprogramming – Davide di Gennaro
 Book: C++ Template Metaprogramming –
Dave Abrahams, Aleksey Gurtovoy

C++ metaprogramming

More Related Content

Similar to C++ metaprogramming (20)

Recently uploaded (20)

C++ metaprogramming