Asumamos,Mover ha envuelto su biblioteca en el espacio de nombres"mover", yAlicia hará que todo el espacio de nombres sea visible dentro de su propia función mediante una sola"usando el espacio de nombres bob", en lugar de"usando bob :: XYZ" por cada artículo individual:

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

Por otro lado, Bob intentó evitar tales escenarios alenvolviendo la implementación dentro de un espacio de nombres ficticio, y haciendosolo estos símbolos disponibles, que están destinados a otros usuarios:

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

}

Debido a que todas las directivas de uso están envueltas en un espacio de nombres "impl_" ficticio dentro del espacio de nombres principal de Bobs, Alice no corre el riesgo deimportar accidentalmente símbolos desde el espacio de nombres std :: también.

Entonces, mis preguntas son:No me gusta que haya un espacio de nombres ficticio para los detalles de implementación, que es "teóricamente" visible para todos.¿Hay alguna manera mejor de utilizar muchos símbolos de for e. sol. std :: sin filtrar estos Y sin prefijar cada símbolo explícito con std ::? (También estoy pensando en los API-Docs generados, que muestran "bob :: impl _ :: XYZ" en lugar de "bob :: XYZ").Creo que no es muy SECO repetir std :: a. s. o. una y otra vez en todas partes. También entiendo que un "uso de std de espacio de nombres" relativamente global dentro de un alcance mayor (como una clase) no es tan hermoso, pero cientos de prefijos std :: son mucho más feos, en mi opinión.Además de los problemas de envenenamiento: ¿Cuál crees que es mejor y POR QUÉ? ¿O tienes una idea completamente diferente?

OK, espero que mi pregunta sea clara. ¡Gracias por leer! :)