variadic-templates

The only and imo very inconvenient caveat of std::array is that it can't deduce its size from the initializer list like built-in C arrays, it's size must be passed as a template. Is it possible to implement a std::array-like container (a thin wrapper around a built-in C array) with a C++11 initializer_list? I ask because, unlike std::array, it would automatically deduce the size of the array from the initializer list which is a lot more convenient. For example: // il_array is the hypothetical container // automatically deduces its size from the initalizer list il_array <int> myarr = {2, 4, 6,

Is there a possibility to have a static assertion whether a type provided as template argument implements all of the types listed in the parameter pack ie. a parameter pack aware std::is_base_of()? template <typename Type, typename... Requirements> class CommonBase { static_assert(is_base_of<Requirements..., Type>::value, "Invalid."); ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ parameter pack aware version of std::is_base_of() public: template <typename T> T* as() { static_assert(std::is_base_of<Requirements..., T>::value, "Invalid."); return reinterpret_cast<T*>(this); } }; Update for C++17: With C+

Consider the following artificial example: template <typename T, typename... Args> struct A { typedef T Type; }; Using A with 1 or more arguments works while using it with zero arguments fails as expected: error: wrong number of template arguments (0, should be 1 or more) Is it possible to make A handle the case of zero template arguments defining A::Type to int if there are no arguments and to the first template argument if there are? First define the primary template as the most general case — which also includes zero argument: template <typename... Args> //general : 0 or more struct A {

If I try to compile the following code I get the following compiler error (see code.) It compiles without error if std::endl is removed. #include <iostream> #include <sstream> #include <utility> namespace detail { template <class T> void print(std::ostream& stream, const T& item) { stream << item; } template <class Head, class... Tail> void print(std::ostream& stream, const Head& head, Tail&&... tail) { detail::print(stream, head); detail::print(stream, std::forward<Tail>(tail)...); } } template <class... Args> void print(std::ostream& stream, Args&&... args) //note: candidate function not

Can I use variadic templates without using the template parameters as function parameters? When I use them, it compiles: #include <iostream> using namespace std; template<class First> void print(First first) { cout << 1 << endl; } template<class First, class ... Rest> void print(First first, Rest ...rest) { cout << 1 << endl; print<Rest...>(rest...); } int main() { print<int,int,int>(1,2,3); } But when I don't use them, it doesn't compile and complains about an ambiguity: #include <iostream> using namespace std; template<class First> void print() { cout << 1 << endl; } template<class First,

Is it possible to do mixing of types and nontypes in variadic template parameters? If I were to pass a std::array for instance to this class as parameter T , I would need to also pass a type for the array and a length, but the way I tried it below causes an error when encountering a value, because it only expects types for Types : template < template<class, std::size_t> class T, class ... Types> class C { T<Types...> storage; }; int main(){ C<std::array, int, 3> c; } Error message: error: template argument for template type parameter must be a type Container<std::array, int, 3> c; ^ Is there a

std::experimental::apply has the following signature: template <class F, class Tuple> constexpr decltype(auto) apply(F&& f, Tuple&& t); It basically invokes f by expanding t 's elements as the arguments. I would like something that does the exact same thing, but with multiple tuples at the same time: template <class F, class... Tuples> constexpr decltype(auto) multi_apply(F&& f, Tuples&&... ts); Example usage: std::tuple t0{1, 2, 3}; std::tuple t1{4, 5, 6}; auto sum = [](auto... xs){ return (0 + ... + xs); }; assert(multi_apply(sum, t0, t1) == 1 + 2 + 3 + 4 + 5 + 6); I can think of various