我将通过我的一个项目进入 C++ 领域。基本上我来 来自 Java 背景并且想知道 Java 包的概念如何 在 C++ 世界中实现。这使我想到了命名空间的 C++ 概念。

到目前为止，我对命名空间完全没问题，但是当涉及到头文件时 就完全合格的类(class)而言，事情变得有点低效 名称、使用指令和使用声明。

问题的一个很好的描述是 this Herb Sutter 的文章。

据我所知，这一切都归结为:如果你总是写一个头文件 使用完全限定的类型名称来引用来自其他命名空间的类型。

这几乎是 Not Acceptable 。作为 C++ header 通常提供声明 在一个类中，最大的可读性是重中之重。完全合格的每个 最后，来自不同 namespace 的类型会产生大量视觉噪音 将标题的可读性降低到提出问题的程度 是否完全使用命名空间。

尽管如此，我还是想利用 C++ 命名空间，所以考虑了一下 问题:如何克服 C++ 头文件的 namespace 之害？后 一些研究我认为 typedef 可以有效解决这个问题。

您将在下面找到一个 C++ 示例程序，它演示了我将如何 喜欢使用公共(public)类范围的 typedef 从其他命名空间导入类型。 该程序在语法上是正确的，并且可以在 MinGW W64 上正常编译。到目前为止 很好，但我不确定这种方法是否愉快地删除了 using 关键字 从标题但带来了另一个我根本不知道的问题。 就像 Herb Sutter 所描述的事情一样棘手。

那是我恳请所有对 C++ 有透彻了解的人 查看下面的代码，让我知道这是否可行。谢谢 征求您的意见。

MyFirstClass.hpp

#ifndef MYFIRSTCLASS_HPP_
#define MYFIRSTCLASS_HPP_

namespace com {
namespace company {
namespace package1 {

class MyFirstClass
{
public:
    MyFirstClass();
    ~MyFirstClass();

private:

};

} // namespace package1
} // namespace company
} // namespace com

#endif /* MYFIRSTCLASS_HPP_ */

MyFirstClass.cpp

#include "MyFirstClass.hpp"

using com::company::package1::MyFirstClass;

MyFirstClass::MyFirstClass()
{
}

MyFirstClass::~MyFirstClass()
{
}

MySecondClass.hpp

#ifndef MYSECONDCLASS_HPP_
#define MYSECONDCLASS_HPP_

#include <string>
#include "MyFirstClass.hpp"

namespace com {
namespace company {
namespace package2 {

    /*
     * Do not write using-declarations in header files according to
     * Herb Sutter's Namespace Rule #2.
     *
     * using std::string; // bad
     * using com::company::package1::MyFirstClass; // bad
     */

class MySecondClass{

public:
    /*
     * Public class-scoped typedefs instead of using-declarations in
     * namespace package2. Consequently we can avoid fully qualified
     * type names in the remainder of the class declaration. This
     * yields maximum readability and shows cleanly the types imported
     * from other namespaces.
     */
    typedef std::string String;
    typedef com::company::package1::MyFirstClass MyFirstClass;

    MySecondClass();
    ~MySecondClass();

    String getText() const; // no std::string required
    void setText(String as_text); // no std::string required

    void setMyFirstInstance(MyFirstClass anv_instance); // no com::company:: ...
    MyFirstClass getMyFirstInstance() const; // no com::company:: ...

private:
    String is_text; // no std::string required
    MyFirstClass inv_myFirstInstance; // no com::company:: ...
};

} // namespace package2
} // namespace company
} // namespace com

#endif /* MYSECONDCLASS_HPP_ */

MySecondClass.cpp

#include "MySecondClass.hpp"

/*
 * According to Herb Sutter's "A Good Long-Term Solution" it is fine
 * to write using declarations in a translation unit, as long as they
 * appear after all #includes.
 */
using com::company::package2::MySecondClass; // OK because in cpp file and
                                             // no more #includes following
MySecondClass::MySecondClass()
{
}

MySecondClass::~MySecondClass()
{
}

/*
 * As we have already imported all types through the class scoped typedefs
 * in our header file, we are now able to simply reuse the typedef types
 * in the translation unit as well. This pattern shortens all type names
 * down to a maximum of "ClassName::TypedefTypeName" in the translation unit -
 * e.g. below we can simply write "MySecondClass::String". At the same time the
 * class declaration in the header file now governs all type imports from other
 * namespaces which again enforces the DRY - Don't Repeat Yourself - principle.
 */

// Simply reuse typedefs from MySecondClass
MySecondClass::String MySecondClass::getText() const
{
    return this->is_text;
}

// Simply reuse typedefs from MySecondClass
void MySecondClass::setText(String as_text)
{
    this->is_text = as_text;
}

// Simply reuse typedefs from MySecondClass
void MySecondClass::setMyFirstInstance(MyFirstClass anv_instance)
{
    this->inv_myFirstInstance = anv_instance;
}

// Simply reuse typedefs from MySecondClass
MySecondClass::MyFirstClass MySecondClass::getMyFirstInstance() const
{
    return this->inv_myFirstInstance;
}

main.cpp

#include <cstdio>
#include "MySecondClass.hpp"

using com::company::package2::MySecondClass; // OK because in cpp file and
                                             // no more #includes following
int main()
{
    // Again MySecondClass provides all types which are imported from
    // other namespaces and are part of its interface through public
    // class scoped typedefs
    MySecondClass *lpnv_mySecCls = new MySecondClass();

    // Again simply reuse typedefs from MySecondClass
    MySecondClass::String ls_text = "Hello World!";
    MySecondClass::MyFirstClass *lpnv_myFirClsf =
            new MySecondClass::MyFirstClass();

    lpnv_mySecCls->setMyFirstInstance(*lpnv_myFirClsf);

    lpnv_mySecCls->setText(ls_text);
    printf("Greetings: %s\n", lpnv_mySecCls->getText().c_str());

    lpnv_mySecCls->setText("Goodbye World!");
    printf("Greetings: %s\n", lpnv_mySecCls->getText().c_str());

    getchar();

    delete lpnv_myFirClsf;
    delete lpnv_mySecCls;

    return 0;
}

最佳答案

通过降低复杂性来减轻痛苦。您正在将 C++ 转换为 Java。 (这和尝试其他方法一样糟糕。)

一些提示:

• 删除“com”命名空间级别。 (这只是一个你不需要的 java-ism)
• 删除“公司”命名空间，也许替换为“产品”或“库”命名空间(即 boost、Qt、OSG 等)。只需选择一些独特的 w.r.t.您正在使用的其他库。
• 您不需要完全声明与您所在的同一命名空间中的名称(警告买者:模板类，请参阅注释)。只需避免在 header 中使用任何 using namespace 指令。 (如果有的话，在 C++ 文件中小心使用。首选内部函数。)
• 考虑命名空间别名(在函数/cpp 文件中)，即 namespace bll = boost::lambda;。这会创建非常简洁的快捷方式。
• 此外，通过使用 pimpl 隐藏私有(private)成员/类型模式，您的 header 可以公开的类型较少。

P.S:感谢@KillianDS 在评论中提供了一些很好的提示(当我将它们编辑到问题中时已将其删除。)

关于c++ - 如何克服C++头文件的命名空间之恶？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/14530144/