c++ - subprogramas - subrutinas arduino

¿Las funciones con argumentos de clase se filtran de un espacio de nombres?

Question

Tengo un pequeño código aquí para su consideración que me desconcierta bastante. Lo extraño es que se compila tanto en Sun Studio como en GCC, aunque creo que no debería.

Considera esto:

namespace name
{
  class C
    {
      int a;
    };

  void f(C c);
  void g(int a);
}

int main(int argc, char** argv)
{
  name::C c;

  name::f(c); 
  f(c);  // <--- this compiles, strangely enough

  name::g(42);
  // g(42);  <--- this does not, as I expected
}

El argumento de clase del mismo espacio de nombres hace que la función f filtre fuera del espacio de nombres y sea accesible sin el name:: .

¿Alguien tiene una explicación para esto? Ciertamente soy yo y no el compilador que está equivocado aquí.

Answer 1

Eso es causado por la búsqueda dependiente del argumento .

Answer 2

Esta es la búsqueda de nombre dependiente del argumento , también conocida como ADL, también conocida como búsqueda de Koenig. Esto se inventó para hacer que los operadores funcionen como se esperaba, por ejemplo:

namespace fu {
    struct bar { int i; };
    inline std::ostream& operator<<( std::ostream& o, const bar& b ) {
        return o << "fu::bar " << b.i;
    }
}

fu::bar b;
b.i = 42;
std::cout << b << std::endl; // works via ADL magic

Sin ADL tendrías que llevar explícitamente al operador de salida con feo using fu::operator<<; , o usa una llamada explícita aún más fea:

fu::operator<<( std::cout, b ) << std::endl;

Answer 3

Se debe a "búsqueda dependiente de argumento". Eliminar la const no cambiará el comportamiento que estás viendo. Para demostrar que es ADL, intente mover la estructura fuera del espacio de nombres ...

struct St
{
   int a;
};

namespace name
{
  void f(const St& st);
  void g(int a);
}

int main(int argc, char** argv)
{
  St st;

  name::f(st); 
  f(st);  // <--- now you will get the expected compile error

  name::g(42);
  // g(42);  <--- this does not, as I expected
}

Answer 4

Se llama búsqueda dependiente del argumento (o búsqueda Koenig). En resumen, el compilador buscará la función en los espacios de nombres que son los espacios de nombres de los tipos de argumentos.