template-argument-deduction

Deduction guides and variadic class templates with variadic template constructors – mismatched argument pack lengths

To simplify your example further, it appears that GCC does not implement variadic template arguments in deduction guides: https://wandbox.org/permlink/4YsacnW9wYcoceDH I didn’t see any explicit mention of variadic templates in the wording for deduction guides in the standard or on cppreference.com. I see no interpretation of the standard that disallows this. Therefore I think this is … Read more

Partial class template argument deduction in C++17

CTAD (Class Template Argument Deduction) is an all or nothing process currently. You either specify nothing and allow the compiler to deduce all of the arguments, or you specify all of the arguments taking the compiler out of the loop. There is a paper (P1021R0) which asks for this and more, but it has not … Read more

Variadic deduction guide not taken by g++, taken by clang++ – who is correct?

This is gcc bug 80871. The issue is, we end up with this set of candidates for deduction: template <class… Types, class… Args> list<Types…> __f(Args… ); // constructor template <class… Args> list<Args…> __f(Args… ); // deduction-guide Both are valid (Types… can deduce as empty in the first case), but the call here should be ambiguous … Read more

Deduce template argument from std::function call signature

A function pointer of type bool (*)() can be converted to std::function<bool()> but is not the same type, so a conversion is needed. Before the compiler can check whether that conversion is possible it needs to deduce ReturnT as bool, but to do that it needs to already know that std::function<bool()> is a possible conversion, … Read more

Workaround for template argument deduction in non-deduced context

You can move the operator into the inner class body and put friend before it. Then replace the parameter type by just inner. Another technique is to derive inner from a CRTP base parameterized by inner. Then make the parameter type the CRTP class and cast the parameter reference to the derived inner class, the … Read more

Template deduction for function based on its return type?

That cannot be done. The return type does not take part in type deduction, it is rather a result of having already matched the appropriate template signature. You can, nevertheless, hide it from most uses as: // helper template <typename T> void Allocate( GCPtr<T>& p ) { p = GC::Allocate<T>(); } int main() { GCPtr<A> … Read more

What is the partial ordering procedure in template deduction

While Xeo gave a pretty good description in the comments, I will try to give a step-by-step explanation with a working example. First of all, the first sentence from the paragraph you quoted says: For each of the templates involved there is the original function type and the transformed function type. […] Hold on, what … Read more

What are template deduction guides and when should we use them?

Template deduction guides are patterns associated with a template class that tell the compiler how to translate a set of constructor arguments (and their types) into template parameters for the class. The simplest example is that of std::vector and its constructor that takes an iterator pair. template<typename Iterator> void func(Iterator first, Iterator last) { vector … Read more

What is a nondeduced context?

Deduction refers to the process of determining the type of a template parameter from a given argument. It applies to function templates, auto, and a few other cases (e.g. partial specialization). For example, consider: template <typename T> void f(std::vector<T>); Now if you say f(x), where you declared std::vector<int> x;, then T is deduced as int, … Read more