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
There are two important reasons for templates not to do any deduction (the two that I remember in a discussion with the guy in charge) Concerns about future language extensions (there are multiple meanings you could invent – what about if we wanted to introduce perfect forwarding for braced init list function arguments?) The braces … Read more
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
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
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
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
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
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
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