template-meta-programming

I have a problem where I need to map an integer at compile time to another integer. Basically, I need the compile-time equivalent of std::map<int,int> . If a key is not found in the map, I'd like to return a default value. The interface I'd like to use: template<unsigned int default_value, unsigned int key0, unsigned int value0, unsigned int key1, unsigned int value1, ...> struct static_map { ... }; template<unsigned int key, typename StaticMap> struct lookup { static unsigned int value = ... }; lookup returns the value associated with key in the StaticMap . If key is not found, then default

C++14 will have functions whose return type can be deduced based on the return value. auto function(){ return "hello world"; } Can I apply this behaviour to functions that use enable_if for the SFINAE by return type idiom? For example, let's consider the following two functons: #include <type_traits> #include <iostream> //This function is chosen when an integral type is passed in template<class T > auto function(T t) -> typename std::enable_if<std::is_integral<T>::value>::type { std::cout << "integral" << std::endl; return; } //This function is chosen when a floating point type is passed in

Let's say, I have six types, and they each belong in a conceptual category. Here is a diagram that shows this: Or Perhaps a more specific example for you: I want to write two functions that will handle all 6 types. Types in "Category 1" get handled a certain way, and types in "Category 2" get handled a different way. Let's get into the code. First, I'll create the six types. //Category 1 Types class Type_A{}; class Type_B{}; class Type_C{}; //Category 2 Types class Type_D{}; class Type_E{}; class Type_F{}; Next, I'll create two type traits so that the category of the type can be discovered at

I want to write a C++ metafunction is_callable<F, Arg> that defines value to be true , if and only if the type F has the function call operator of the form SomeReturnType operator()(const Arg &) . For example, in the following case struct foo { void operator(const int &) {} }; I want is_callable<foo, int &> to be false and is_callable<foo, const int &> to be true . This is what I have so far : #include <memory> #include <iostream> template<typename F, typename Arg> struct is_callable { private: template<typename> static char (&test(...))[2]; template<unsigned> struct helper { typedef void

The question is in bold at the bottom, the problem is also summarized by the distillation code fragment towards the end. I am trying to unify my type system (the type system does to and from from type to string) into a single component(as defined by Lakos). I am using boost::array , boost::variant , and boost::mpl , in order to achieve this. I want to have the parser and generator rules for my types unified in a variant. there is a undefined type, a int4(see below) type and a int8 type. The variant reads as variant<undefined, int4,int8> . int4 traits: struct rbl_int4_parser_rule_definition {

What are the coolest examples of metaprogramming that you've seen in C++? What are some practical uses of metaprogramming that you've seen in C++? Ferruccio Personally, I think Boost.Spirit is a pretty amazing example of meta-programming. It's a complete parser generator that lets you express grammars using C++ syntax. JaredPar The most practical use of meta programming is turning a runtime error into a compile time error. Example: Lets call the interface IFoo. One of my programs dealt with a COM object that had multiple paths to IFoo (very complicated inheritance hierarchy). Unfortunately the

I have the following function which can take N arguments of different types, and forwards them to N functions templated on each individual type, in this manner (example with two arguments): template <typename T1, typename T2> bool func(int& counter, T1 x1, T2 x2) { switch (counter) { case 0: if (func2<T1>(x1)) { counter++; return true; } else { return false; } case 1: if (func2<T2>(x2)) { counter++; return true; } else { return false; } default: return true; } } I want to write this function with variadic templates so that it can handle any number of arguments in a type-safe way. I can see a