如何在另一个命名空间中键入一个命名空间的枚举并使用ist c ++ [重复]

Question

可能重复：
How do you import an enum into a different namespace in C++?

如何解决以下枚举命名空间问题？

namespace A {
    typedef enum ABar { a, b };

    void foo( ABar xx ) {}
}

namespace B {
    typedef enum A::ABar BBar;

        void foo( BBar xx ) { A::foo( xx ); } 
}

int main() {
    B::foo( B::a ); // 'a' : is not a member of 'B'
                    // 'a' : undeclared identifier
}

Answer 1

你不能 typedef 一个枚举。你可以使用它：

namespace B {
   using A::ABar;
}

编辑

这是修改后的示例，可以正常工作：

namespace A {
    enum ABar { a, b };

    void foo( ABar xx ) {}
}
namespace B {
    using A::ABar;        // 'ABar' : is injected into namespace 'B'
    using A::a;           // 'a' : is injected into namespace 'B'

        void foo( ABar xx ) { A::foo( xx ); }
}
int main() {
    B::foo( B::a );
}

但是，正如 CygnusX1 和 David 指出的那样，以上内容正在污染命名空间 B，最好这样做：

namespace A {
    enum ABar { a, b };

    void foo( ABar xx ) {}
}
namespace B {
        void foo( A::ABar xx ) { A::foo( xx ); }
}
int main() {
    B::foo( A::a );
}

还有第三个选项，对它进行类型定义，但要正确：

namespace B {
    typedef A::ABar BBar;

        void foo( BBar xx ) { A::foo( xx ); } 
}

但你仍然不能这样做：

B::foo( B::a ); // 'a' : is not a member of 'B'
                // 'a' : undeclared identifier

因为 BBar 只是 A::ABar 的别名。

Answer 2

问题在于枚举的声明不仅创建了类型，而且还声明了具有给定值的枚举标识符。当您执行 typedef 时，您只是为该类型创建了一个本地别名，但这些值不会被带到新的命名空间。也就是说，编译器将看到B::BBar，它会通过typedef 知道您指的是A::ABar。但是在处理B::a 时，B 命名空间中没有任何内容引用它。

为此，您还必须将a 和b 带入新命名空间，这不是由typedef 完成的，因为它们不是类型。无论如何，它是可实现的，例如：

namespace A {
   enum ABar {
       a, b
   };
}
namespace B {
   typedef ::A::ABar BBar;
   using ::A::a;
   using ::A::b;
}

我不建议这样做，因为它会很快成为维护问题（您必须记住，每次更改原始名称空间时都要更新两个名称空间。

至于如何处理这个问题，@CygnusX1 提出的解决方法实际上是一个不错的选择，如果您使用的是 C++0x 编译器，该语言允许使用类似的习惯用法，因为它允许访问枚举值通过枚举类型：

namespace A {
   enum ABar { a,b };
}
namespace B {
   typedef A::ABar BBar;
}
int main() {
   std::cout << B::BBar::a << std::endl; // extra enum qualification
}

Answer 3

当您 typedef 一个类型时，您不会导入该命名空间中定义的符号。所以虽然你可以写：

int main() {
    B::BBar enumVariable=A::a;
}

您无法访问B::a，因为此符号不存在。

一个部分的解决方法，在我看来，一种使代码更干净的方法，虽然写的时间也更长，是将每个枚举打包到自己的结构中，例如：

struct ABar {
    enum Type {a, b};
};

typedef ABar BBar;

int main() {
    ABar::Type var=ABar::a;
    BBar::Type var2=BBar::a;
}

如果您仍然需要它，您将能够将 ABar 打包到一个命名空间中，并且通常也可以在另一个命名空间中进行 typedef。