ADL找不到模板化的自由函数

我试图了解ADL是如何工作的，至少是它的基础知识，并创建了以下代码：

#include <iostream>
#include <string>
#include <vector>  
using std::pair;
using std::string;
using std::vector;
namespace My {
using std::to_string;
/** With these forward declarations it works ...
string to_string(char arg);
const string& to_string(const string& str);
template <typename T>
string to_string(const vector<T>& rhs);
template <typename T1, typename T2>
string to_string(const pair<T1, T2>& rhs);
struct A;
string to_string(const A& rhs);
*/
string to_string(char arg)
{
return string(1, arg);
}
const string& to_string(const string& str)
{
return str;
}
template <typename T>
string to_string(const vector<T>& rhs)
{
string str("");
for (const auto& e : rhs) {
str += to_string(e) + " ";      //< this fails with `pair<..>`
/// `(to_string)(e)` would fail even with `A`
}
return str;
}
template <typename T1, typename T2>
string to_string(const pair<T1, T2>& rhs)
{
return to_string(rhs.first) + " " + to_string(rhs.second);
}
struct A {
static int counter;
string to_string() const
{
using My::to_string;    //< avoid using `A::to_string`
return to_string("<A>[") + to_string(counter++) + to_string("]");
}
};
int A::counter = 0;
string to_string(const A& rhs)
{
return rhs.to_string();
}
}
int main(int /*argc*/, const char* /*argv*/[])
{
using My::to_string;
using My::A;
using std::cout;
using std::endl;
cout << to_string(3.1415) << endl;
cout << to_string(pair<int, char>{5, 'a'}) << endl;
cout << to_string(pair<double, pair<int, int>>{3.14, {1, 2}}) << endl;
cout << to_string(vector<int>{1, 2, 3}) << endl;
cout << to_string(pair<string, vector<int>>{"key", {1, 2, 3}}) << endl;
cout << to_string(pair<string, A>{"key", {}}) << endl;
cout << to_string(vector<A>{{}, {}, {}}) << endl;
/// this will fail to compile
cout << to_string(vector<pair<string, int>>{{"a", 1}, {"b", 2}}) << endl;
return 0;
}

我发现，在My内部，如果存在std::自由函数，using std::to_string将使用它，否则将使用My::。然后，在名称空间My之外，执行using My::to_string就足以覆盖这两种情况。到目前为止还好。

然后，我在成员函数A::to_string中使用了相同的技术，以避免更喜欢函数本身而不是自由函数(这同样适用于任何其他成员函数)。

最后，我对to_string(vector<A>)的编译感到有点惊讶，尽管A不是正向声明的。正如我所理解的，这就是ADL的作用所在。禁用它(将to_string括在括号中)将导致编译失败。

长话短说之后，我的问题来了：为什么ADL在这种情况下不适用于模板化函数，即to_string(pair<T1, T2>)？更重要的是，如何修复它？如果不需要执行前向声明，我会很高兴，因为在我的用例中，to_string(vector<T>)的定义位于某个基本头文件中，而后者的定义位于不同的头文件中并且此时不应该是已知的。

编辑：

我试图通过一些模板甚至一些SFINAE以某种方式"伪造"所需的前向声明，但这要么导致歧义，要么导致相同的结果。最后，我提出了使用所需类的成员函数to_string(但它可以是任何其他名称)的解决方案。如果需要与to_string兼容，则需要始终实现此函数，在STL容器的情况下，需要继承它们并添加成员函数。但我相信，在这种情况下，ADL永远不会失败。

以下是代码的修改部分：

template <typename T,
typename Fun = decltype(&T::to_string),
typename = std::enable_if_t<
std::is_member_function_pointer<Fun>::value>>
string to_string(const T& rhs)
{
return rhs.to_string();
}
template <typename T>
struct Vector : public vector<T> {
using vector<T>::vector;
string to_string() const
{
using My::to_string;    //< avoid using `Vector::to_string`
string str("");
for (const auto& e : *this) {
str += to_string(e) + " ";
}
return str;
}
};
template <typename T1, typename T2>
struct Pair : public pair<T1, T2> {
using pair<T1, T2>::pair;
string to_string() const
{
using My::to_string;    //< avoid using `Pair::to_string`
return to_string(this->first) + " " + to_string(this->second);
}
};

然而，必须将vectors和pairs替换为Vectors和Pairs。(不再需要自由函数to_string(A))。

其他解决方案，意见？