¿Cómo puedo definir amigos en el espacio de nombres global dentro de otro espacio de nombres C++?

Question

Me gustaría definir un operador binario en el espacio de nombre global. El operador trabaja en una clase que está definida en otro espacio de nombres y el operador debe obtener el acceso a los miembros privados de esa clase. El problema que tengo es que no conozco el alcance de ese operador global cuando lo hago amigo en la definición de la clase.

he intentado algo así como:

namespace NAME 
{ 
    class A { 
     public: 
      friend A ::operator * (double lhs, const A& rhs); 
     private: 
      int private_var; 
    }; 
} 

A operator * (double lhs, const A& rhs) 
{ 
    double x = rhs.private_var; 
    ... 
} 

El compilador (g ++ 4.4) que no sabía qué hacer con él. Parece que la línea

friend A ::operator *() 

se evalúa como algo parecido (pseudo-código)

(A::operator) 

en lugar de

(A) (::operator) 

Si dejo el :: en la declaración de la Operador de la compilación funciona pero el operador se encuentra en el espacio de nombres NOMBRE y no en el espacio de nombres global.

¿Cómo califico el espacio de nombre global en una situación así?

Answer 1

En primer lugar, tenga en cuenta que su declaración operador le faltaba un título de espacio de nombres para A:

NAME::A operator * (double lhs, const NAME::A& rhs) 

y luego el truco decisiva es agregar paréntesis, a la declaración amigo como este, al igual que usted propuso en su "pseudo -code"

friend A (::operator *) (double lhs, const A& rhs); 

para hacer que todo compilar, este caso es necesario algunas declaraciones adelantadas, al llegar a este:

namespace NAME 
{ 
    class A; 
} 

NAME::A operator * (double lhs, const NAME::A& rhs); 

namespace NAME 
{ 
    class A { 
     public: 
      friend A (::operator *) (double lhs, const A& rhs); 
     private: 
      int private_var; 
    }; 
} 

NAME::A operator * (double lhs, const NAME::A& rhs) 
{ 
    double x = rhs.private_var; 
} 

Alexander tiene razón, sin embargo, probablemente debería declarar al operador en el mismo espacio de nombres como sus parámetros.

Answer 2

No sé la respuesta exacta a su pregunta.

Pero es terriblemente mala idea definir el operador fuera del espacio de nombre de sus parámetros (ahora se corta la búsqueda dependiente del argumento que es muy útil para los operadores).

Answer 3

Esto compila, supongo sin probar que también funciona. Tenga en cuenta el uso de los paréntesis:

namespace NAME {class A; } 
NAME::A operator * (double lhs, const NAME::A& rhs); 

namespace NAME 
{ 
    class A { 
     public: 
      friend A (::operator *) (double lhs, const A& rhs); 
     private: 
      int private_var; 
    }; 
} 

NAME::A operator * (double lhs, const NAME::A& rhs) 
{ 
    double x = rhs.private_var; 
    return rhs; 
} 

int main() {} 

Como se menciona Alexander, sin embargo, su pregunta no explica por qué el operador no está a nombre de espacio de nombres. De cualquier manera, se puede llamar como 1.0 * some_A_instance. Entonces puedes estar creando problemas innecesarios para ti.

Answer 4

Es posible - se puede encerrar el declarador entre paréntesis: friend A (::operator * (double lhs, const A& rhs));

También es necesario con visión de declarar tanto la clase y la función.

namespace NAME {class A;} 
NAME::A operator *(double lhs, const NAME::A& rhs); 

// ... 

namespace NAME 
{ 
    class A { 
     public: 
      friend A (::operator * (double lhs, const A& rhs)); 
     private: 
      int private_var; 
    }; 
} 

NAME::A operator *(double lhs, const NAME::A& rhs) { 
    //... 
} 

Pero estoy de acuerdo con Andreas en que es mejor definir ambos en el mismo espacio de nombres si es posible.