Hi, everyone.
According to the following rules: Two sets of types are used to determine the partial ordering. For each of the templates involved there is the original function type and the transformed function type. [ Note: The creation of the transformed type is described in [temp.func.order]. — end note ] The deduction process uses the transformed type as the argument template and the original type of the other template as the parameter template.
And the transformed processes are described as the following:
To produce the transformed template, for each type, non-type, or template template parameter (including template parameter packs thereof) synthesize a unique type, value, or class template respectively and substitute it for each occurrence of that parameter in the function type of the template. [ Note: The type replacing the placeholder in the type of the value synthesized for a non-type template parameter is also a unique synthesized type. — end note ] If only one of the function templates M is a non-static member of some class A, M is considered to have a new first parameter inserted in its function parameter list. Given cv as the cv-qualifiers of M (if any), the new parameter is of type “rvalue reference to cv A” if the optional ref-qualifier of M is && or if M has no ref-qualifier and the first parameter of the other template has rvalue reference type. Otherwise, the new parameter is of type “lvalue reference to cv A”.
So, I have a confusion here, Is the "first parameter inserted in its function parameter list" considered as the process for making transformed function type? If it is, how to interpret this example:
struct A { };
template<class T> struct B {
template<class R> int operator*(R&); // #1
};
template<class T, class R> int operator*(T&, R&); // #2
when during the partial ordering, the original type for `#1` is `int(R&)`, the transformed type for `#1` is `int(B<T>&, R&)` and, the original type and transformed type for `#2` are all `int(T&,R&)`. That means, the original type for `#1` does not have the same number parameters as that of transformed type for `#2`.
Hence, my question is , Is the result of the process which is bolded in the above rule considered as the original type or as the transformed type? If it is a later case, how to interpret the above example?