template-templates

This question on the object generator pattern got me thinking about ways to automate it. Essentially, I want to automate the creation of functions like std::make_pair , std::bind1st and std::mem_fun so that instead of having to write a different function for each template class type, you could write a single variadic template template function that handles all cases at once. Usage of this function would be like: make<std::pair>(1, 2); // equivalent to std::make_pair(1, 2) make<std::binder2nd>(&foo, 3); // equivalent to std::bind2nd(&foo, 3); Is it possible to write this function make ? I have

This question already has an answer here: Deducing first template argument with other template parameters defaulted 2 answers Consider the following code: template<typename T> struct A { }; // same as A, but with one extra defaulted parameter template<typename T, typename F = int> struct B { }; template<template<typename> typename T> T<int> build() { return {}; } int main() { build<A>(); // works in gcc and clang build<B>(); // works in gcc, does not work in clang } g++ (7.3.0) compiles the code just fine, however, clang++ (5.0.1) emits the following: example.cpp:14:5: error: no matching

Every allocator class must have an interface similar to the following: template<class T> class allocator { ... template<class Other> struct rebind { typedef allocator<Other> other; }; }; And classes that use allocators do something redundant like this: template<class T, class Alloc = std::allocator<T> > class vector { ... }; But why is this necessary? In other words, couldn't they have just said: template<class T> class allocator { ... }; template<class T, template<class> class Alloc = std::allocator> class vector { ... }; which is both more elegant, less redundant, and (in some similar