Wie überwinden Sie den namespace böse von C++ - header-Dateien?

Mit einem meiner Projekte will ich den Kopf in den C++ Bereich. Grundsätzlich bin ich kommen
aus einem Java-hintergrund und Frage mich, wie das Konzept der Java-Pakete
realisiert sich in der C++ Welt. Dies führte mich zu der C++ - Konzept der namespaces.

Ich bin vollkommen zufrieden mit namespaces, so weit, aber wenn es um die header-Dateien
die Dinge sind immer irgendwie ineffizient mit Bezug auf voll qualifizierte Klasse
Namen, using-Direktiven und using-Deklarationen.

Eine sehr gute Beschreibung des Problems ist diese Artikel von Herb Sutter.

Wie ich es verstehe, das kommt darauf an: Wenn Sie schreiben Sie eine header-Datei immer
mit vollständig qualifizierten Typnamen beziehen sich auf Typen aus anderen Namensräumen.

Das ist fast inakzeptabel. Als C++ - header-allgemein liefert die Erklärung
einer Klasse, maximal Lesbarkeit hat oberste Priorität. Voll qualifizierende jeder
geben Sie von einem anderen namespace erstellt eine Menge von visuellen Lärm, schließlich
abnehmende Lesbarkeit des headers zu einem gewissen Grad, was die Frage aufwirft,
ob namespaces überhaupt.

Dennoch möchte ich um die Vorteile von C++ namespaces und so setzen einige Gedanken in
die Frage: Wie überwinden Sie den namespace böse von C++ - header-Dateien? Nach
einige der Forschung, ich denke, typedefs konnte ein gültiges Heilmittel für dieses problem.

Folgenden finden Sie ein C++ Beispielprogramm, das veranschaulicht, wie würde ich
wie zu verwenden public class Gültigkeitsbereich typedefs zu importieren, Typen aus anderen Namensräumen.
Das Programm ist syntaktisch korrekt und kompiliert problemlos auf MinGW-W64. So weit, So
gut, aber ich bin mir nicht sicher, ob dieser Ansatz glücklich beseitigt die Verwendung von keyword
aus dem Kopf-aber bringt ein anderes problem, das bin ich einfach nicht bewusst.
Nur etwas tricky, wie die Dinge beschrieben, von Herb Sutter.

Dass ist ich bitte alle, die ein gründliches Verständnis von C++
überprüfen Sie den code unten und lassen Sie mich wissen, ob dies funktionieren sollte, oder nicht. Dank
für Ihre Gedanken.

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