Point of template instantiation, dependent names and ADL - c++

Question

It's my understanding from post that argument dependent lookup is used when template dependent names are bound at the point of instantiation. I understand the first simple form below, however am unsure how exactly ADL and binding works on the second. I have a specific question regarding overriding sort().
Appreciate if anyone can guide me on how ADL and binding is occurring in the second code post. Also, if there is a way to redefine sort() to not bind to the std::sort and to bind to some other implementation.
template<typename T> T f(T a) {
// Can find ::ns::g(Q) only via ADL on T for
// an instantiation of f with T == ::ns::Q.
return g(a);
}
namespace ns {
class Q {};
Q g(Q e) { return e; }
} // namespace ns
int main() {
(void) f(::ns::Q{});
return 0;
}
Form that I need help with:
#include <iostream>
#include <vector>
template<typename T>
void print_sorted(std::vector<T>& v)
{
//typename std::vector<T>::iterator it;
sort(v.begin(),v.end()); // ADL looks at return type of begin()?
for (const auto& x : v)
std::cout << x << '\n';
}
int main(int argc, char *argv[])
{
std::vector<std::string> v = {"b", "a"};
print_sorted(v); // sort using std::sort, then print using std::cout
return 0;
}
#include <algorithm> // adl of sort() would allow std::sort to be defined here
Compilation:
clang++ -pedantic -Wall -std=c++11 test187.cc && ./a.out
a
b

Answer 1

I tried the OP's code on Godbolt. Just as OP claimed, it compiles under Clang (and, it seems, on GCC as well). If #include <algorithm> is commented out, both compilers claim that the name sort is unknown to them.
I believe that the reason for this behaviour is that these compilers defer the instantiation of the print_sorted function until the end of the translation unit. The license to do so is given by C++17 [temp.point]/8:
A specialization for a function template, a member function template, or of a member function or static
data member of a class template may have multiple points of instantiations within a translation unit, and
in addition to the points of instantiation described above, for any such specialization that has a point
of instantiation within the translation unit, the end of the translation unit is also considered a point of
instantiation. A specialization for a class template has at most one point of instantiation within a translation
unit. A specialization for any template may have points of instantiation in multiple translation units.
If two different points of instantiation give a template specialization different meanings according to the
one-definition rule (6.2), the program is ill-formed, no diagnostic required.
In other words, regardless of where the function template specialization is instantiated, it is also considered to be instantiated at the end of the translation unit, and all such instantiations must have the same meaning, otherwise the program is ill-formed NDR.
Thus, the compiler writers may defer function template instantiations, as much as possible, until the end of the translation unit, possibly for efficiency reasons, without being concerned that this would change the meaning of the program. If it does change the meaning of the program, it means that the programmer messed up and the compiler is not required to catch this mistake. (See also CWG 993)
The wording of [temp.point]/8 is unclear as to whether it applies to the OP's program (since here, at one point of instantiation, the specialization is actually ill-formed due to using an undeclared name, as opposed to simply having a different meaning than it does at another point of instantiation). I think this is just a defect in the wording, and GCC and Clang are following the "spirit" of the rule.