如果我在一个头文件的命名空间中定义了一个默认函数'foo':

//DefaultFoo.h
namespace DefaultFooNamespace
{
    template <typename T>
    void foo(T& x){/*...*/}
}

以及在一个或多个其他头文件中的另一个命名空间中定义的foo的重载，例如foooverloads.h:

//FooOverloads.h
namespace FooOverloadsNamespace
{
    template <typename T>
    void foo(std::vector<T>& x){/*...*/}

    void foo(std::string& x){/*...*/}

    //etc.
}

我还有另一个函数'bar'，它在将DefaultFooNamespace和FooOverloadsNamespace命名空间都纳入作用域之后调用foo（注意，我在bar.h中只包含DefaultFoo.h，因为DefaultFoo.h在一个命名空间中只包含一个函数，该命名空间永远不会扩展，而FooOverloadsNamespace将通过添加额外的重载来扩展）:

//Bar.h
#include "DefaultFoo.h" 

namespace BarNamespace
{
    template <typename T>
    void bar(T& x)
    {
        //... do stuff then call foo
        using DefaultFooNamespace::foo;
        using FooOverloadsNamespace::foo;
        foo(x);
    }
}

除非确保fooOverloads.h在bar.h的。include之前是。includeded，或者确保fooOverloads.h在bar.h中是。includeded，或者我为FooNamespace中的一个虚拟类提供了一个'foo'函数的声明，并在bar.h中提供了。include，否则'bar'将无法编译，例如。

//Dummy.h:
struct DummyClass
{
private:
    DummyClass(){}
};
namespace FooNamespace
{
    inline void foo(DummyClass& x);  //purely to open up namespace
}

//Bar.h
#include "Dummy.h"

有没有什么办法可以绕过这个问题，这样我就可以定义bar，并且避免不得不创建冗余代码来在bar中打开FooNamespace？