ricerca Argument-dependent comportarsi in modo imprevisto sui tipi alias da un altro spazio dei nomi

Question

Ho appena incontrato alcuni comportamenti interessanti con la ricerca argomento-dipendente, che non capiscono fino in fondo:

#include <iostream> 

namespace a { 
struct Foo { 
    Foo(int v1, int v2) : v1(v1), v2(v2) { } 
    int v1,v2; 
}; 
} 

namespace b { 
template <typename T> 
struct Baz : T { 
    using T::T; 
}; 
} 

namespace c { 
using Foo = ::b::Baz< ::a::Foo>; 

// (1) NOT FOUND BY ADL 
// std::ostream& operator << (std::ostream& os, const Foo& foo) 
// { 
// return os << foo.v1 << "," << foo.v2; 
// } 
} 

namespace b { 

// (2) FOUND BY ADL 
std::ostream& operator << (std::ostream& os, const ::c::Foo& foo) 
{ 
    return os << foo.v1 << "," << foo.v2; 
} 

} 

int main() 
{ 
    c::Foo foo(1,2); 
    // Variant (1): ADL fails: should it not find 
    // c::operator<<(std::ostream&, const Foo&) ? 
    // Variant (2) compiles 
    std::cout << "foo: " << foo << std::endl; 
} 

ottengo che c::Foo è in realtà b::Baz<...>, quindi in qualche modo ha senso che ADL trovi l'operatore quando lo definisco all'interno di namespace b. Ma sembra sfidare l'intuizione che la definizione dell'operatore all'interno di namespace c non funzioni, poiché c::Foodovrebbe (IMHO) consentire al compilatore di eseguire ADL anche all'interno di namespace c.

Perché non è così? Qual è la logica alla base di questo?

Answer 1

[basic.lookup.argdep]/2:

nomi typedef e dichiarazione using s utilizzati per specificare i tipi non contribuiscono a questo insieme.

Né i nomi typedef né le dichiarazioni di utilizzo sono affiliati al tipo che designano. Se lo fossero (che sarebbe effettivamente controintuitivo, IMO), le cose si spezzerebbero molto facilmente; solo perché ho typedef qualche classe, tutte le chiamate stanno ora valutando funzioni aggiunte in prossimità del typedef, che è praticamente mai desiderato:

#include <string> 

namespace A { 
    using str = std::string; 
    int stoi(str); // This will be a candidate in e.g. stoi(std::string{"0.4"}), 
        // leading to potentially different behavior or ambiguity 

namespace B { 
    int stoi(std::string); // This is no candidate, because...? 
}