如何获得模板函数以查看以后定义的其他全局方法

（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的名称空间全局方法，还有一些覆盖它们的模板函数。到目前为止，一切都很好，一切都很好。但是，现在我有了另一个标题，我有类似以下定义的标题：

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

因此，现在我在其他地方定义了其他类型，并且我还定义了我的漂亮打印命名空间中的另一个to_string覆盖，以指示如何将我的新类型转换为字符串。将两个标题扔进一个文件中，类似的东西：

#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，btw），说在模板to_string方法中，没有匹配的函数为了致电" to_string（const user :: service＆amp;）'，这完全匹配定义和包含的我的方法。如果我扭转了#include订购的效果，则可以正常工作。

所以，我推测该模板仅查看其前面定义的方法。有什么解决方案吗？鉴于我的项目范围和复杂的＃包括的范围，简单地说"始终确保它们以正确的顺序达到"不是一个可处理的解决方案，并且会在代码中引入过多的复杂脆弱性。基本TO_STRING定义是那些往往会在许多地方升起的文件之一，因此请确保任何其他恰好包含to_string Override的随机类型定义首先无法正常工作。<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<</p>

我在某些地方使用的另一个解决方案是我在基本文件中定义了一个可打印的接口：

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(); }
}

该定义是在同一文件中的模板方法之前进行的。因此，这对于可以简单地添加该界面并实现的课程非常有用。除了这里的任何出色解决方案之外不依赖#include下令工作。

无论如何，你们都如何看待这些选择？我没有想到的方法可能会很好吗？

从答案启发的解决方案给出了

此代码实际上确实编译了，因此您可以将其复制并使用它，我认为我已经捕获了所有相关用例以及什么无效，无效以及原因。

#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)
}