问题标签 [nested-class]

考虑你有以下课程

我想我在某处读过（但不是官方的 Java 教程），如果我将静态成员类属性声明为私有，编译器必须生成某种访问器方法，以便外部类可以实际访问静态成员类的 (这实际上是一个包私有的顶级类）属性。

有什么想法吗？

使用嵌套类对常量进行分组有什么问题？

像这样：

像这样使用：

您还可以使“常量”类部分...

请看下面的示例代码：

在 A 类和 B 类实现中：

编译器在方法 foobar() 中标记对 foo() 的调用。早些时候，我将 foo() 作为类 A 的私有成员函数，但假设 B 的函数看不到它，则更改为 public。当然，它没有帮助。我正在尝试重用 A 方法提供的功能。为什么编译器不允许这个函数调用？正如我所看到的，它们是同一个封闭类（A）的一部分。我认为在 C++ 标准中封闭类的嵌套类成员的可访问性问题已解决。

如果不为 B 重写相同的方法 (foo())，我如何才能实现我想要做的事情，这使 B 嵌套在 A 中？

我正在使用 VC++ 编译器版本 9（Visual Studio 2008）。感谢您的帮助。

我在想，如果一个类只在另一个类中实例化，那么在该类中使用它是正确的。我认为这将有助于我们进行良好的设计。当我查看我的项目时，我几乎从未见过这样的嵌套结构。但是如果我尝试嵌套类，那么这次我脑海中会出现另一个问题。例如

我有 Board 类、Move 类，如 ShortCastle、LongCastle、EnPassant、Promote 和 Pawn、Queen、Rook、Knight 等棋子。所以很明显 Board 类将实例化 Piece 类，而 Piece 类将实例化 Move 类。对于一个好的设计，Promote move 类应该嵌套在 Pawn 中，因为只有 pawn 才能提升自己。短和长 Castles 应该嵌套在 King 中，因为只有 King 才能有这种类型的动作。

尝试将所有 Piece 类放入 Board 类看起来并不好设计，因为 8-9 类将在 Board 类中，并且它真的会烦人 Board 类文件太大且难以阅读。我更喜欢将每个 Piece 类保留在另一个文件。很好，我们可以创建部分 Board 类，但仍然不是很烦人 8-9 Partial Board 类文件将包含每个部分类？不让它们嵌套更好吗？Pieces 也一样 为另一个 Move 类型类创建另一个部分 Piece 文件？如果嵌套类只占用很小的空间，那么它不会有任何问题，但如果它需要很多方法？

在调试了我的代码一段时间后，我使用 enable_if 将问题的原因归结为一些意想不到的模板专业化结果：

以下代码在 Visual Studio 2010（和 2008）中的 DoTest() 中的断言失败，而在 g++ 3.4.5 中则没有。但是，当我从SomeClass中删除模板或将my_condition移出SomeClass的范围时，它也可以在 MSVC 中使用。

这段代码是否有问题可以解释这种行为（至少部分），或者这是 MSVC 编译器中的错误？

（使用此示例代码对于 boost 和 c++0x stl 版本是相同的）

当试图通过将条件移出范围来修复它时，我还注意到在使用 std::enable_if 时这还不够，但至少它适用于 boost::enable_if：

我希望有人对此有解释。

我正在使用 NHibernate。我有一个具有嵌套类型的类。除了使用原生 SQL 查询之外，还有什么方法可以使用 NHibernate 来查询嵌套类型？

HQL 目前不允许嵌套类。

编辑：外部类有一个嵌套类实例的 IList。

请考虑以下代码：

我希望所有的实例都成为any的foo<T>::bar朋友。如果不是嵌套模板，则上面的语法可以正常工作。但是当我做例如foo<T>::bar<S>Sbar

MSVC8 (Visual C++ 2005) 不喜欢它：

如果我使用，编译器会给我同样的错误

反而。我怎样才能达到我想要的？

编辑：我仔细检查了（这里是早上，我并没有真正醒来），这似乎是一个VC8 错误：

在这个 stackoverflow 的回答中，一位评论者提到“私有嵌套类”可能非常有用，所以我在诸如这篇文章之类的文章中阅读了它们，这些文章倾向于解释嵌套类在技术上的功能，而不是为什么要使用它们。

我想我会为属于较大类的小助手类使用私有嵌套类，但通常我需要另一个类的助手类，所以我只需要付出额外的努力来（1）使嵌套类不-nested 或 (2) 将其公开，然后使用外部类前缀对其进行访问，这似乎都是额外的工作，而没有任何附加值首先具有嵌套类。因此，总的来说，我真的看不到嵌套类的用例，除了可能使类更加组织成组，但这也违背了我开始享受的每个文件一个类的清晰度.

您以何种方式使用嵌套类来使您的代码更易于管理、更易读、更高效？

为什么下面的例子有错误？

是否有另一种创建方式ClassE，而不是通过键入class ClassA; class ClassE？

I got an unexpected closure when creating a nested class. I suspect that this is something related to metaclasses, super, or both. It is definitely related to how closures get created. I am using python2.7.

Here are five simplified examples that demonstrate the same problem that I am seeing (they all build off the first):

EXAMPLE 1:

EXAMPLE 2:

EXAMPLE 3:

EXAMPLE 4:

EXAMPLE 5:

Here is what I understand (referencing examples):

• Metaclasses are inherited, so Subclass gets Base’s metaclass.
• Only __init__ is affected, Subclass.other method is not (#1).
• Removing Subclass.other does not make a difference (#1).
• Removing self.name=name from Subclass.__init__ does not make a difference (#1).
• The object in the closure cell is not a function.
• The object is not Metaclass or Base, but some object of type Metaclass, just like Base is (#1).
• The object is actually an object of the type of the nested Subclass (#1).
• The closure cells for t1.subclass.__init__ and t1.subclass2.__init__ are the same, even though they are from two different classes (#1).
• When I do not nest the creation of Subclass (#1) then there is no closure created.
• When I do not call super(...).__init__ in Subclass.init__ no closure is created (#2).
• If I assign no __metaclass__ and inherit from object then the same behavior shows up (#3).
• The object in the closure cell for t3.other.__init__ is t3.other (#3).
• The same behavior happens if the metaclass has no __init__ (#4).
• The same behavior happens if the Base has no __init__ (#4).
• The closure cells for the three subclasses in example 4 are all different and each matches the corresponding class (#4).
• When super(...).__init__ is replaced with Base.__init__(self), the closure disappears (#5).

Here is what I do not understand:

• Why does a closure get set for __init__?
• Why doesn't the closure get set for other?
• Why is the object in the closure cell set to the class to which __init__ belongs?
• Why does this only happen when super(...).__init__ is called?
• Why doesn't this happen when Base.__init__(self) is called?
• Does this actually have anything at all to do with using metaclasses (probably, since the default metaclass is type)?

Thanks for the help!

-eric

(Update) Here is something that I found then (based on Jason's insight):

First, a function's name is in scope within its own body. Second, functions get closures for the functions in which they are defined if they reference those functions.

I hadn't realized that the function name was in scope like that. The same goes for classes. When a class is defined within a function's scope, any references to that class name inside the class's methods cause the class to bound in a closure on that method's function, like so:

However, since closures cannot be created on non-functions the following fails:

Good stuff!