template-meta-programming

What is the best way to determine a common numeric type in a template parameter pack with: the smallest size, no loss of precision, and no risk of overflow/underflow when converting any type in the parameter pack to this "ideal" common type? The variadic template ( best_common_numeric_type ) could be used like so: template<typename... NumericTypes> auto some_numeric_func(const NumericTypes&...) -> typename best_common_numeric_type<NumericTypes...>::type; And have instantiations like the following: [1] best_common_numeric_type<long, unsigned long, float, double, int>::type = double [2] best

I want a function that will behave like std::transform for tuples. Basically the functionality to be implemented is template<size_t From, size_t To, class Tuple, class Func> void tuple_transform(Tuple&& source, Tuple&& target, Func f) { // elements <From, To> of `target` ti become `f(si)`, where // si is the corresponding element of `source` }; I believe that to implement this I'll need a compile time integer range struct, a generalization of std::index_sequence and I've implemented it here with cti::range . I also believe that this type of compile time traversal is ideal here : template<class

Related: Ambiguous overload accessing argument-less template functions with variadic parameters Simple variadic template function can't instantinate Why is this variadic function ambiguous? Consider this pair of variadic templates: template<typename Dummy> bool All(Param& c) { return true; } template<typename Dummy, Func* f, Func* ...rest> bool All(Param& c) { return f(c) && All<Dummy, rest...>(c); } This works and compiles. However, how to write it without the first template parameter? Sounds trivial? Well, that's what I thought. :-) Let's consider some ideas. Idea #1: template<Func* f, Func*

I've been trying to think up a creative solution to this problem (on and off) for some time, but I have not as of yet been able to. I recently considered that it might be solvable with template metaprogramming, though I am not sure due to my relative lack of experience with the technique. Is it possible to use template metaprogramming (or any other mechanism with the C++ language) to count the number of classes which are derived from some base class such that each derived class is given a unique, static class identifier? Thanks in advance! No. This is a problem that comes up in practice quite

How can one check if two parameter packs are the same, ignoring their internal order? So far I only have the frame (using std::tuple ), but no functionality. #include <tuple> #include <type_traits> template <typename, typename> struct type_set_eq : std::false_type { }; template <typename ... Types1, typename ... Types2> struct type_set_eq<std::tuple<Types1...>, std::tuple<Types2...>> : std::true_type { // Should only be true_type if the sets of types are equal }; int main() { using t1 = std::tuple<int, double>; using t2 = std::tuple<double, int>; using t3 = std::tuple<int, double, char>;