C++ 如何在C+；中以更少的空间定义类字段/方法+；

这是我的标题：

#ifndef MYCLASSES_H_
#define MYCLASSES_H_

#define ARRAY_SIZE(x) (sizeof((x)) / sizeof((x)[0]))

namespace mynamespace {

class A
{
    class B
    {
        class C
        {
            void doStuff(B *pB);
        }

        static const C SOME_ARRAY[];
        static const int SOME_ARRAY_COUNT;
    }
}

} //namespace mynamespace
#endif /* MYCLASSES_H_ */

这就是CPP：

#include "myclasses.h"

namespace mynamespace {

void A::B::C::doStuff(A::B *pB)
{
    /* ... */
}

const A::B::C A::B::SOME_ARRAY[] = {
    /*...*/
};

const A::B::SOME_ARRAY_COUNT = ARRAY_SIZE(

} //namespace mynamespace

#include "myclasses.h"


namespace
{
    // This is an anonymouse namespace
    // It does not export it symbols outside the compilation unit.
    // So only A should be able to see them
    class B
    {
            static const C SOME_ARRAY[];
            static const int SOME_ARRAY_COUNT;
    };
    class C
    {
            void doStuff(B *pB);
    };
}
void C::doStuff(B *pB)
{
    /* ... */
}

const C B::SOME_ARRAY[] = {
    /*...*/
};

const B::SOME_ARRAY_COUNT = ARRAY_SIZE(

---

如何使.CPP文件中的定义具有更短的名称？它非常麻烦。

可能会尝试使用using声明：

using A::B;

---

不幸的是，你不能。这只是C++的一个句法性质。 因此，您应该更喜欢C++中的平面嵌套层次结构：不要无休止地嵌套类，而是将它们放在同一上层命名空间中。在其他语言中，这是一个很大的禁忌，因为它向公共接口泄漏了实现细节。1

<>在C++中不是这样的，因为这里有不同的编译单元来强制封装和信息隐藏。因此，在大多数情况下，平面层次结构实际上是很好的

---

---

1但即使在其他语言中，也有三个嵌套类在发挥作用。

typedefs可以缩短命名时间：

#include "MYCLASSES.h"

namespace mynamespace {

typedef A::B b;
typedef b::C c;

void c::doStuff(b *pB)
{
    /* ... */
}

const c b::SOME_ARRAY[100] = {
    /*...*/
};

const int b::SOME_ARRAY_COUNT = ARRAY_SIZE(SOME_ARRAY);

} //namespace mynamespace

---

没有干净的方法来做这件事。如果是嵌套名称空间，则可以使用

使用

或

名称空间别名

因为是课堂，我能想到的最好的方法是：

#define B A::B
#define C B::C

---

但它绝对不干净。我不会这么做的

除了像这样的事情之外，没有真正的方法可以做到这一点：

    #define AB mynamespace::A::B;

为此：

    mynamespace::A::B::C myobj;

注意，许多程序员（包括我自己）认为这是一种糟糕的做法，因为AB是什么并不明显

成为：

    AB::C myobj;

不能对类使用“using”，只能对名称空间使用。因此，在cpp文件中，您可以执行以下操作：

    using mynamespace;
    A::B::C myobj;

但不是：

    using mynamespace::A::B;
    C myobj;

---

不过，一般来说，许多人都认为最佳做法是完全限定名称。

或者，您可以在头文件中编写实现。不过，这是一个非常糟糕的做法

---

那个人走进一位医生。他说：“医生，当我把它撞到墙上时，我的头很痛。”。医生说：“不要把头撞在墙上，你的头就不会疼了。”

由于B和C在a级的私人区域，世界看不到它们

因此，无需将它们嵌套在一个容器中，只需使它们对外部世界不可见即可。
实现这一点的简单方法是将它们放在源文件内的匿名命名空间中

#ifndef MYCLASSES_H_
#define MYCLASSES_H_

#define ARRAY_SIZE(x) (sizeof((x)) / sizeof((x)[0]))

namespace mynamespace {

class A
{
}

} //namespace mynamespace
#endif /* MYCLASSES_H_ */

这就是CPP：

#include "myclasses.h"

namespace mynamespace {

void A::B::C::doStuff(A::B *pB)
{
    /* ... */
}

const A::B::C A::B::SOME_ARRAY[] = {
    /*...*/
};

const A::B::SOME_ARRAY_COUNT = ARRAY_SIZE(

} //namespace mynamespace

#include "myclasses.h"


namespace
{
    // This is an anonymouse namespace
    // It does not export it symbols outside the compilation unit.
    // So only A should be able to see them
    class B
    {
            static const C SOME_ARRAY[];
            static const int SOME_ARRAY_COUNT;
    };
    class C
    {
            void doStuff(B *pB);
    };
}
void C::doStuff(B *pB)
{
    /* ... */
}

const C B::SOME_ARRAY[] = {
    /*...*/
};

const B::SOME_ARRAY_COUNT = ARRAY_SIZE(

---

你真的需要3个内部类吗？不光是利用继承权更好吗？男人走进医生那里。他说：“医生，当我把它撞到墙上时，我的头很痛。”。医生说：“不要把头撞在墙上，你的头就不会疼了。”。由于B和C在a级的私人区域，世界看不到它们。因此，不需要将它们嵌套在一个容器中，只需使它们对外部世界不可见即可。最简单的方法是将它们放在源文件中的匿名名称空间中。@LokiAstari我正要写这个。顺便说一句，“将评论转换为答案”按钮在哪里？；）您不应该真正使用数组大小宏，当x是指针时，它将失败（或者会突然衰减为指针）。使用`template size\u t array\u size（t（&）[N]）{return N；}`在未传递实际数组时将出错。不应将保留名称用于包含保护，否则可能会发生这种情况。这仅适用于命名空间范围中的名称；这些在课堂范围内。谢谢。高度赞赏您的努力：-）