(Oktalist 在下面给出了一个很好的答案，请检查它和下面的评论，以帮助证明我们讨论的所有内容，我在我的问题底部添加了一个完整的编译解决方案，以证明讨论的所有内容。)

我有一组命名空间全局方法和模板化方法，如下所示:

namespace PrettyPrint
{
    String to_string(bool val);
    String to_string(char val);
    String to_string(int val);
    String to_string(uint val);
    // ETC...

    template <typename T> String to_string(const T* val)
    {
        if (! val) return U("NULL");
        return String().copy_formatted("(%p)-> %S", (const void*)val, to_string(*val).uchars());
    }

    // ... and more templates to help with containers and such
}

“字符串”类型不是 C++ 字符串，它是从 IBM 的 ICU 库派生的一个特殊类，但与这个问题无关。重点是，我有一堆名为 to_string 的命名空间全局方法，还有一些覆盖它们的模板化函数。到目前为止，一切都很好，一切都很好。但是，现在我有了另一个 header ，其中定义了如下内容:

namespace User 
{
    struct Service {
        int code;
        String name;
    }
    //...
}
namespace PrettyPrint
{
    String to_string(const User::Service& val) { return val.name; }
}

所以，现在我已经在其他地方定义了一些其他类型，并且还在我的 PrettyPrint 命名空间中定义了另一个 to_string 覆盖，以指示如何将我的新类型转换为字符串。将两个 header 放入一个文件中，如下所示:

#include <the to_string and templates header>
#include <the User::Service header>

main() {
    User::Service s = {1, U("foo")};
    User::Service *p = &s;
    PrettyPrint::to_string(s);
    PrettyPrint::to_string(p);
}

(是的，to_string 方法实际上应该在某处返回一个值，而不是重点。)关键是第二次调用给出了一个编译器错误(gcc，顺便说一句)，说明在模板化的 to_string 方法中没有匹配的函数用于调用“to_string(const User::Service&)”，这当然与我定义和包含的方法完全匹配。如果我反转 #include 顺序，它就可以正常工作。

因此，我推测模板只查看在它之前定义的方法。有什么解决办法吗？考虑到我的项目的范围和复杂的#include 的数量，简单地说“始终确保它们以正确的顺序出现”不是一个易于处理的解决方案，并且会在代码中引入太多复杂的脆弱性。基本的 to_string 定义是那些往往会被包含在很多地方的文件之一，因此确保任何其他恰好包含 to_string 覆盖的随机类型定义首先出现是行不通的。

我在某些地方使用的另一个解决方案是我在基础文件中定义了一个 Printable 接口(interface):

namespace PrettyPrint
{
    class Printable {
    public:
        virtual String pretty_print_to_string() const = 0;
    }

    String to_string(const Printable& obj) { return obj.pretty_print_to_string(); }
}

该定义位于同一文件中的模板方法之前。因此，这对于我可以简单地添加到该接口(interface)并实现它的类来说非常有用。这里没有任何好的解决方案，我将简单地尝试始终使用它，但有些地方不方便，我也想了解是否有任何方法可以使方法重载解决方案起作用无需依赖 #include 命令即可工作。

无论如何，你们对这些选项有什么看法？有没有一种我没有想到的可能会很好用的方法？

解决方案灵感来自 Oktalist 给出的答案

这段代码实际上可以编译，因此您可以将其复制下来并使用它，我想我已经捕获了所有相关的用例以及哪些有效，哪些无效以及原因。

#include <iostream>

using namespace std;

namespace PrettyPrint
{
    void sample(int val) { cout << "PrettyPrint::sample(int)\n"; }
    void sample(bool val) { cout << "PrettyPrint::sample(bool)\n"; }
    template<typename T> void sample(T* val) { cout << "PrettyPrint::sample(pointer); -> "; sample(*val); }
}

namespace User
{
    struct Foo {
        int i;
        bool b;
    };

    void sample(const Foo& val) {
        //below doesn't work un-qualified, tries to convert the int (val.i) into a Foo to make a recursive call.
        //meaning, it matches the User namespace version first
        //sample(val.i); doesn't work, tries to call User::sample(const Foo&)

        cout << "User::sample(const Foo&); -> {\n";
        cout << '\t'; PrettyPrint::sample(val.i); //now it works
        cout << '\t'; PrettyPrint::sample(val.b);
        cout << "}\n";
    }
}

namespace Other
{
    void test(User::Foo* fubar) {
        cout << "In Other::test(User::Foo*):\n";
        //PrettyPrint::sample(*fubar); //doesn't work, can't find sample(const User::Foo&) in PrettyPrint
        PrettyPrint::sample(fubar); //works, by argument-dependent lookup (ADL) from the template call
        sample(*fubar); //works, finds the method by ADL
        //sample(fubar); //doesn't work, only sees User::sample() and can't instantiate a Foo& from a Foo*
    }

    void test2(User::Foo* happy) {
        using PrettyPrint::sample; //now both work! this is the way to do it.
        cout << "In Other::test2(User::Foo*):\n";
        sample(*happy);
        sample(happy);
    }
}

int main() {
    int i=0, *p = &i;
    bool b=false;
    User::Foo f = {1, true}, *pf = &f;

    //sample(i);  <-- doesn't work, PrettyPrint namespace is not visible here, nor is User for that matter.
    PrettyPrint::sample(i); //now it works
    //PrettyPrint::sample(f); //doesn't work, forces search in PrettyPrint only, doesn't see User override.

    using namespace PrettyPrint;  // now they all work.
    sample(p);
    sample(b);

    sample(f);
    sample(pf);

    Other::test(pf);
    Other::test2(pf);

    return 0;
}

这会产生以下输出:

PrettyPrint::sample(int)
PrettyPrint::sample(pointer); -> PrettyPrint::sample(int)
PrettyPrint::sample(bool)
User::sample(const Foo&); -> {
    PrettyPrint::sample(int)
    PrettyPrint::sample(bool)
}
PrettyPrint::sample(pointer); -> User::sample(const Foo&); -> {
    PrettyPrint::sample(int)
    PrettyPrint::sample(bool)
}
In Other::test(User::Foo*):
PrettyPrint::sample(pointer); -> User::sample(const Foo&); -> {
    PrettyPrint::sample(int)
    PrettyPrint::sample(bool)
}
User::sample(const Foo&); -> {
    PrettyPrint::sample(int)
    PrettyPrint::sample(bool)
}
In Other::test2(User::Foo*):
User::sample(const Foo&); -> {
    PrettyPrint::sample(int)
    PrettyPrint::sample(bool)
}
PrettyPrint::sample(pointer); -> User::sample(const Foo&); -> {
    PrettyPrint::sample(int)
    PrettyPrint::sample(bool)
}

最佳答案

在两阶段查找的第一阶段，当模板被定义时，非限定查找在模板的直接封闭命名空间中查找依赖和非依赖名称，并且只找到那些 to_string 出现在模板定义之前的重载。

在两阶段查找的第二阶段，当模板被实例化时，参数相关查找 在与作为参数传递给命名函数的任何类类型关联的 namespace 中查找依赖名称。但是因为您的 to_string(const User::Service&) 重载位于 PrettyPrint 命名空间中，所以它不会被参数相关查找找到。

将您的 to_string(const User::Service&) 重载移动到 User 命名空间以使用依赖于参数的查找，这将找到在该点声明的任何重载模板实例化，包括在模板定义点之后声明的任何内容。

另见 http://clang.llvm.org/compatibility.html#dep_lookup

关于c++ - 我怎样才能让我的模板函数看到以后定义的其他全局方法？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/22333301/