Angenommen,Bo hat seine Bibliothek in den Namespace eingepackt"Bob" und Alice wird den gesamten Namespace in ihrer eigenen Funktion durch ein einziges @ sichtbar mach "using namespace bob", Anstatt von "using bob :: XYZ" für jeden einzelnen Artikel:

// This file is written by Alice:
#include <iostream>

// She uses Bobs library:
#include "bob.hpp"

int main(void) {
    // Import Bobs library and use it:
    using namespace bob;

    unsigned short value = 50000;
    bob::dump_as_signed(value);

    // Should not be possible without std:: prefix:
    cout << "foobar" << endl;
}

uf der anderen Seite versuchte Bob, solche Szenarien durch @ zu verhinderUmhüllung der Implementierung in einen Dummy-Namespace, und machennur diese Symbole verfügbar, welche für andere Benutzer bestimmt sind:

// This file is written by Bob
#include <iostream>
#include <type_traits>

// Namespace for public use:
namespace bob {

    // Implementation details:
    namespace impl_ {

        // Visible ONLY within sub-namespace:
        using std::cout;
        using std::endl;

        using std::is_integral;
        using std::make_signed;

        // No repeated std:: prefixes at all:
        template <typename T,
            typename S = typename make_signed<T>::type>
        void dump_as_signed(const T i) {
            static_assert(is_integral<T>::value, "no integer");

            // Do something very very useful:
            cout << "signed:" << static_cast<S>(i) << endl;
        }
    }

    // Make available without poisoning with std::*:
    using impl_::dump_as_signed;

}

Da alle using-Anweisungen in einen Dummy-Namespace "impl_" innerhalb des Bobs-Major-Namespace eingeschlossen sind, besteht für Alice kein Risiko fürversehentlich Symbole aus dem std :: -Namensraum importieren, auch

Also, meine Fragen sind: Ich mag es nicht, dass es einen Dummy-Namespace für Implementierungsdetails gibt, der "theoretisch" für alle sichtbar ist.ibt es eine schönere Möglichkeit, viele Symbole aus für e verwenden zu können. G. std :: ohne diese UND zu verlieren, ohne dass jedes Symbol explizit mit std ::? @ vorangestellt wi (Ich denke auch an generierte API-Docs, die "bob :: impl _ :: XYZ" anstelle von "bob :: XYZ" anzeigen.)Ich denke, es ist nicht sehr trocken, std :: a zu wiederholen. s. Ö. immer wieder überall. Ich verstehe auch, dass eine relativ globale "Verwendung des Namespace std" in einem größeren Bereich (wie einer Klasse) nicht so schön ist, aber meiner Meinung nach sind Hunderte von std :: -Präfixen viel hässlicher.Neben Vergiftungsproblemen: Was findest du schöner und WARUM? Oder hast du eine ganz andere Idee?

OK, ich hoffe meine Frage ist klar. Danke fürs Lesen! :)