Funzioni autonome nello spazio dei nomi globale

Quando si scrivono funzioni non associate e libere, possono essere inserite nello spazio dei nomi globale fintanto che la firma specifica un oggetto con scope dello spazio dei nomi? Ad esempio, nel codice seguente, la progettazione accettabile per "Esempio 2"? Quale è meglio, Esempio 1 o Esempio 2? La tua risposta cambia se la funzione è un sovraccarico dell'operatore?

Ricerca: Non penso che questa domanda sia stata affrontata quando ho preso una classe di programmazione C ++ (o potrebbe essere stata affrontata prima che io fossi pronto a capirlo). Ho provato a cercare la risposta con alcune varianti diverse delle parole chiave, ma non ho ottenuto risultati di qualità.

#include <iostream>
#include <string>
#include <sstream>

/* Example 1 */
namespace myapp
{
    namespace xyz
    {
        class Thing
        {
        public:
            Thing( int value ) : myValue( value ) {}
            void setValue( int value ) { myValue = value; }
            int getValue() const { return myValue; }
        private:
            int myValue;
        };
        std::string toString( const Thing& thing )
        {
            std::stringstream ss;
            ss << thing.getValue();
            return ss.str();
        }
    }
}

/* Example 2 */
namespace myapp
{
    namespace xyz
    {
        class AnotherThing
        {
        public:
            AnotherThing( int value ) : myValue( value ) {}
            void setValue( int value ) { myValue = value; }
            int getValue() const { return myValue; }
        private:
            int myValue;
        };
    }
}
std::string toString( const myapp::xyz::AnotherThing& thing )
{
    std::stringstream ss;
    ss << thing.getValue();
    return ss.str();
}

int main(int argc, const char * argv[])
{
    /* Example 1 */
    myapp::xyz::Thing t( 1 );
    std::cout << myapp::xyz::toString( t ) << std::endl;

    /* Example 2 */
    myapp::xyz::AnotherThing a( 2 );
    std::cout << toString( a ) << std::endl;

    return 0;
}