Here’s another solution, which is more generic (applicable to any expression, without defining a separate template each time). This solution leverages that (1) lambda expressions can be constexpr as of C++17 (2) the type of a captureless lambda is default constructible as of C++20. The idea is, the overload that returns true is selected when … Read more
You could use something like this. Everything happens at compile time. Specialize base_typename_struct to define your primitive types. template <const char* str, int len, char… suffix> struct append { static constexpr const char* value() { return append<str, len-1, str[len-1], suffix…>::value(); } }; template <const char* str, char… suffix> struct append<str, 0, suffix…> { static const … Read more
Firstly, C++11 did not carry forward boost’s disable_if. So if you’re going to transition boost code, you’ll need to use enable_if with a negated condition (or redefine your own disable_if construct). Secondly, for SFINAE to reach in and apply to the method level, those methods must be templates themselves. Yet your tests have to be … Read more
I made an example of what you want that you can see at my blog site. In this is case it’s a JSON serializer that works with nested structs. It uses a ‘more Boost’ solution since I saw it in the Boost.Serialization library. (See also below and live on Coliru.) The solution uses Fusion Sequence … Read more
This is what I call the magic switch problem — how to take a (range of) run time values and turn it into a compile time constant. Abstractly, you want to generate this switch statement: switch(n) { (case I from 0 to n-1: /* use I as a constant */)… } You can use parameter … Read more
One of pre-C++17 ways is to use partial template specializations, like here: template <typename T, bool AorB> struct dummy; template <typename T, true> struct dummy { static void MyFunc() { FunctionA<T>(); } } template <typename T, false> struct dummy { static void MyFunc() { FunctionB<T>(); } } template <typename T> void Facade() { dummy<T, MeetsConditions<T>::value>::MyFunc(); … Read more
As you have already been hinted, the best way is to use a tuple: template<typename …AcceptedTypes> // e.g. MyClass<T1, T2> class MyClass { std::tuple<std::vector<AcceptedTypes>…> vectors; }; This is the only way to multiply the “fields” because you cannot magically make it spell up the field names. Another important thing may be to get some named … Read more
This is sufficient assuming a standards conforming compiler (with respect to the one definition rule): template<typename T> class A { public: static char ID_storage; static const void * const ID; }; template<typename T> char A<T>::ID_storage; template<typename T> const void * const A<T>::ID= &A<T>::ID_storage; From the C++ standard 3.2.5 One definition rule [basic.def.odr] (bold emphasis mine): … Read more
It’s ugly, and probably not the best way to sort in a constant expression (because of the required instantiation depth).. but voilà, a merge sort: Helper type, returnable array type with constexpr element access: #include <cstddef> #include <iterator> #include <type_traits> template<class T, std::size_t N> struct c_array { T arr[N]; constexpr T const& operator[](std::size_t p) const … Read more
In C++11: template <int kk, int vv> struct kv { static const int k = kk, v = vv; }; template <int dflt, typename…> struct ct_map; template <int dflt> struct ct_map<dflt> { template<int> struct get { static const int val = dflt; }; }; template<int dflt, int k, int v, typename… rest> struct ct_map<dflt, kv<k, … Read more