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

How can I define the class fields/methods in less space in C++

本文关键字：定义 空间 字段 方法 C++      更新时间：2023-10-16

这是我的标题：

#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

如何使.CPP文件中的定义具有较短的名称？它非常笨重。

一名男子走进一名医生。他说："医生，我的头撞到墙上时很疼。"。医生说："不要把你的头撞在墙上，你的头就会停止疼痛。"。

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

所以没有必要把它们嵌套在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
{
    // 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(

可以尝试使用using声明：

using A::B;

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

很遗憾，您不能。这只是C++的一个语法特性。

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

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

1但即使在其他语言中，三个嵌套类也在突破极限。

没有干净的方法。如果是嵌套的命名空间，可以使用using或namespace aliasing。

既然是课堂，我能想到的最好的就是：

#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;

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

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

相关文章：