下面是一个例子：

void f(int);
template<typename T>
void g(T x) {
    f(x);  // Lookup of f here finds f(int)
}
void f(double);
struct S {};
void f(S);
int main() {
    g(0);  // Calls f(int) found through early lookup
    g(0.0);  // Still calls f(int) since f(double) can't be found via ADL
    g(S());  // Calls f(S) found via ADL
}

当调用f(x)时，候选函数是通过“正常”查找+在通过ADL关联的所有命名空间的作用域中查找找到的名称。正常的查找可以被认为是语义上发生在函数模板的声明中，而不是任何特定的专门化（g<int>，g<double>或g<S>）示例化。

带有依赖函数参数的非限定查找考虑：

• 在模板定义处可见的函数（和变量），AND
• 在模板示例化时通过ADL执行函数。

我认为这句话是想说，候选函数的列表可能在定义时构建（前半部分），然后在示例化期间的查找之前增加（后半部分）。

请考虑以下示例：

template <typename T>
struct foo_unqualified : T {
    foo_unqualified() {
        b<T>();
    }
};

没有b，因此有error：

<source>:5:9: error: there are no arguments to 'b' that depend on a template parameter, so a declaration of 'b' must be available [-fpermissive]
    5 |         b<T>();
      |         ^~~~

现在考虑这个例子：

template <typename T>
struct foo_qualified : T {
    foo_qualified() {
        foo_qualified::template b<T>();
    }
};

这里还没有定义foo_qualified::b，这就是为什么这里的编译器需要关键字typename。
只有在示例化时，才会真正查找名称：

struct bar {
    template <typename T>
    void b(){}
};
struct no_bar {};
int main() {
    foo_qualified<bar> f; 
    foo_qualified<no_bar> f2; // error
}

foo_qualified<bar>的示例化很好。foo_qualified<bar>继承自bar，现在有一个foo_qualified<bar>::b()模板。foo_qualified<no_bar>失败，因为查找失败（现在仅在示例化时）。
Live Demo