C++ 是否有从另一个命名空间中定义成员的变通方法？

这似乎有点深奥，但我有一个这样的类结构，其中一个单例模板类是在不同的命名空间中定义的，而不是实际使用它的类

namespace F{
    template<typename>
    struct Foo{
        static Foo instance;
    };
}

namespace B{
    struct Bar{};
    F::Foo<Bar> F::Foo<Bar>::instance; //error C2888
}

名称空间F{
模板
结构Foo{
静态Foo实例；
};
}
命名空间B{
结构条{}；
F:：Foo F:：Foo:：instance；//错误C2888
}

这将产生：

error C2888: 'Foo<void> Foo<void>::instance' : symbol cannot be defined within namespace 'B'

错误C2888:'Foo Foo:：instance'：无法在命名空间“B”中定义符号

我知道应该是这样的，但在我的例子中，

Foo

是我的库的一部分，

Bar

是由客户端定义的，因此它们不一定是同一名称空间的一部分。定义

Foo:：instance

的部分是宏的一部分，因此我可以向用户隐藏复杂性

---

有什么方法可以让我从另一个名称空间中定义一个类的成员吗？

对于您的特殊需要（假设提供的示例代码是相关的），一个简单的解决方案是使用，例如

x、 h

#pragma一次
命名空间F{
模板
结构Foo{
静态Foo实例；
};
模板
Foo-Foo:：实例；
}

a、 cpp

#包括“x.h”
#包括
结构A{}；
静态布尔u=！（std：：cout针对您的特定需求（假设提供的示例代码相关）的一个简单解决方案是使用

x、 h
#pragma一次
命名空间F{
模板
结构Foo{
静态Foo实例；
};
模板
Foo-Foo:：实例；
}

a、 cpp
#包括“x.h”
#包括
结构A{}；
静态bool u=！（std：：在这里看不到我的答案：不，这是不可能的。假设两个（！）带有一个条和一个F:：Foo:：InstanceObject的名称空间是重复声明的对象。我知道它不起作用，我要求了一个解决方法。而且那个解决方案也不能解决我的问题。我甚至不想声明一个类，我只想在其中定义一个符号。@DieterLücking你能详细说明一下吗？这是一个解释还是一个解决方案？@Cheersandhth.-a如果哦，上帝是的！非常感谢，这正是我所需要的！也许我应该问“在实现单例时如何避免定义外部符号的需要”。请参见我的回答：不，这是不可能的。假设两个（！）带有一个条和一个F:：Foo:：InstanceObject的名称空间是重复声明的对象。我知道它不起作用，我要求了一个解决方法。而且那个解决方案也不能解决我的问题。我甚至不想声明一个类，我只想在其中定义一个符号。@DieterLücking你能详细说明一下吗？这是一个解释还是一个解决方案？@Cheersandhth.-a如果哦，上帝是的！非常感谢，这正是我所需要的！也许我应该问“在实现单例时如何避免定义外部符号的需要。”我已经尝试了第二种方法，但要么是我做错了什么，要么是MSVC12不支持。Meyers的singleton是这个问题的最佳解决方案。@Ifreicht:我同意，如果您必须提供对公共对象的访问，那么Meyers的singleton可能是我草拟的两种方法中最好的一种。因为您有一些（未指定）对于直接静态成员方法的问题，我添加了一个完整的具体示例。我已经尝试了第二个示例，但要么我做错了什么，要么MSVC12不支持它。Meyers的singleton是这个问题的最佳解决方案。@Ifreicht:我同意如果必须提供对公共对象的访问，那么Meyers的singleton可能是由于您对直接静态成员方法有一些（未指定）问题，我添加了一个完整的具体示例。
namespace F{
    template<class>
    struct Foo{
        static auto instance() -> Foo& {
            static Foo the_instance;
            return the_instance;
        }
    };
}

namespace F{
    template<class>
    struct Foo{
        static Foo instance;
    };

    template<class Type>
    Foo<Type> Foo<Type>::instance;
}

auto main() -> int {}

#pragma once

namespace F{
    template<class>
    struct Foo{
        static Foo instance;
    };

    template<class Type>
    Foo<Type> Foo<Type>::instance;
}

#include "x.h"

#include <iostream>

struct A {};
static bool u = !(std::cout << "A " << &F::Foo<A>::instance << std::endl);

#include "x.h"

#include "x.h"

#include <iostream>

struct A {};        // Intentionally same as in file "a.cpp"
static bool u = !(std::cout << "A " << &F::Foo<A>::instance << std::endl);

#include "x.h"

#include <iostream>

struct B {};
static bool u = !(std::cout << "B " << &F::Foo<B>::instance << std::endl);

H:\dev\test\so\0169>cl main.cpp a.cpp a2.cpp b.cpp /Feb
main.cpp
a.cpp
a2.cpp
b.cpp
Generating Code...

H:\dev\test\so\0169>b
A 00988A50
A 00988A50
B 00988A6E

H:\dev\test\so\0169>_