argument_dependent_lookup.txt

                               
   ARGUMENT_DEPENDENT_LOOKUP   
                               

ARGUMENT-DEPENDENT      #ADL, aussi appelé Koenig lookup.
LOOKUP ==>              #  FONC( NS::ARG ), où FONC est dans un namespace NS2::, (via using NS2::FONC, ou namespace NS2 {  }) 
                        #  mais pas explicité via NS2::FONC, alors si NS::FONC existe, NS::FONC est utilisé et non NS2::FONC
                        #Utilité :
                        #  - pour les operator non membres d'une classe, mais dans le même namespace que leur premier
                        #    argument, évite de faire NS::operator<<( NS::ARG1, ARG2), mais peut faire directement 
                        #    NS::ARG1 << ARG2
                        #    Exemple : std::ostream <<
                        #  - utiliser FONC( T ), en laisant le namespace T décider du namespace de FONC, avec par défaut un
                        #    FONC dans le namespace courant.
                        #    Exemple : algorithmes standards utilisent swap( T, T ) et non std::swap( T, T ), pour que si 
                        #    un NS::swap( NS::T, NS::T ) est défini, ce soit celui choisi, et non std::swap.
                        #    Problème : 
                        #      - signifie que l'on ignore quel swap(  ) possible sera invoqué. Fait perdre utilité des
                        #        namespaces.
                        #      - si FONC(  ) n'existe pas dans le namespace courant, il faut faire un using NS::FONC pour qu'en
                        #        cas où le namespace de T n'ai pas de FONC(  ), celui par défaut NS::FONC soit utilisé. Par 
                        #        exemple, faire un using std::swap, avant tout swap(  )
                        #      - toute fonction appelant une autre FONC( T ), avec donc un argument template, dans le même 
                        #        namespace, devrait l'appeler sous la forme NS::FONC( T ), au cas où FONC existe aussi
                        #        dans le namespace de T (sauf si c'est intentionnel)
                        #      - même chose pour FONC( NS::VAL ), sauf que l'on savoir si NS::FONC existe (du moins à un 
                        #        instant t) et que si oui, compile-time error.