template-meta-programming

I would like to know how to solve the following problem (C++17): suppose there are several template classes, inherited from each other in CRTP-like fashion (single inheritance only). For a given instantiated template base class, find the class that is furthest from it down the inheritance chain. I first thought that is should be pretty easy, but was not able to accomplish this. To simplify, suppose that every root and every intermediate class has using DerivedT = Derived in its public area. Example: template <class T> struct GetDeepest { using Type = ...; }; template <class T> struct A { using

I am new to metafunctions. I want to write a function that replaces all matches of a certain type in a compound type with some other type. In example: replace<void *, void, int>::type should be int * , replace<void, void, int>::type should be int , etc. I basically failed with two different approaches so far: template < typename C, // Type to be searched typename X, // "Needle" that is searched for typename Y // Replacing type > struct replace { typedef C type; }; // If the type matches the search exactly, replace template < typename C, typename Y > struct replace<C, C, Y> { typedef Y type; };

template<class... Foos> // N = sizeof...(Foos) template<typename... Args> // M = sizeof...(Args) void split_and_call(Args&&... args) { // Using Python notation here... Foos[0](*args[:a]); // a = arity of Foos[0] Foos[1](*args[a:b]); // b-a = arity of Foos[1] ... Foos[N-1](*args[z:M]); // M-z = arity of Foos[N-1] } Assumptions: All types in Foos are callable All types in Foos are unambiguous Any type in Foos may have an arity of 0 Args is the concatenation of all of the argument types used by Foos Can this be done with just Foos and without Args ? I'm actually not sure how to do it even if I

I was playing with Boost.Proto, mostly for fun and to see if in future I could make some use of it in my own projects. That said, as probably most beginners of this library, i've played with a modified version of the 'lazy vector' example, but using transforms instead of contexts to perform the evaluation. The vector is defined as follows (ok, i know, 'vector' is not a good name for something defined at the global namespace scope...) template <std::size_t D, class T> class vector { T data_[D]; enum { dimension = D }; // Constructors, destructors... }; // expression wrapper template <class>

I'd like to parse c++ containers into another object using their ::iterator member type. Containers who's iterator member type points to an object of a single type (vectors, queues, etc.) will turn into a list-like object, and containers who's iterator member type points to an std::pair will turn into a map-like object. I'm trying to write a member function to detect the latter kind of container, but it does not work. Here's what I have so far: #include <tuple> #include <iterator> #include <type_traits> template <typename T> struct is_pair : std::false_type { }; template <typename T, typename

I recently asked a question here ( Detecting instance method constexpr with SFINAE ) where I tried to do some constexpr detection at compile time. Eventually, I figured out that one can exploit noexcept to do this: any constant expression is also noexcept . So I put together the following machinery: template <class T> constexpr int maybe_noexcept(T && t) { return 0; } ... constexpr bool b = noexcept(maybe_noexcept(int{})); This works and b is true as you'd expect, as zero-initializing an int is a constant expression. It also correctly yields zero when it should (if I change int to some other

Say I have a large code using Array of Structures (AoS) memory layout. I would like to build a zero-cost abstraction in C++ which allows me to switch between AoS and SoA with as little refactoring effort as possible. For instance take a class with access member functions struct Item{ auto& myDouble(){ return mDouble; } auto& myChar(){ return mChar; } auto& myString(){ return mString; } private: double mDouble; char mChar; std::string mString; }; which is used inside a container in a loop std::vector<Item> vec_(1000); for (auto& i : vec_) i.myDouble()=5.; I would like to change the first

Does anyone know of a method to use CRTP to count the number of subclasses of an object? Suppose we had a setup similar to the following one: template <typename T> class Object { .... }; const unsigned int ObjectSubClassCount = ...; class Subobject : public Object<SubObject> { .... }; class Second : public Object<Second> { .... }; and so on, such that, using TMP, we might have a constant ( ObjectSubClassCount ) that represents the total number of subclasses? Does anyone know a way to do this? Edit: I am wanting to use the result as a template parameter later on, so I need it to be done with