Как определить друзей в глобальном пространстве имен в другом пространстве имен C++?

Question

Я хотел бы определить бинарный оператор в глобальном пространстве имен. Оператор работает над классом, который определен в другом пространстве имен, и оператор должен получить доступ к частным членам этого класса. Проблема в том, что я не знаю, как охватить этот глобальный оператор, сделав его другом в определении класса.

Я пытался что-то вроде:

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; 
    ... 
} 

компилятор (г ++ 4.4) не знал, что делать с ним. Кажется, что линия

friend A ::operator *() 

оценивается как нечто вроде (псевдо-код)

(A::operator) 

вместо

(A) (::operator) 

Если я выхожу из :: в объявлении из оператор компиляции работает, но оператор находится в пространстве имен NAME, а не в глобальном пространстве имен.

Как я могу квалифицировать глобальное пространство имен в такой ситуации?

Answer 1

Во-первых, обратите внимание, что ваша декларация оператора недоставало квалификации пространства имен A:

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

, а затем решающий Хитрость заключается в том, чтобы добавить скобки к другу декларации, как это, так же, как вы предложили в своем «псевдо -кода»

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

Для того, чтобы все это собрать, затем нужно несколько вперед заявлений, прибывающих на это:

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; 
} 

Александр прав, однако - вы должны, вероятно, объявить оператор в том же пространстве имен, что и его параметры.

Answer 2

Не знаю, какой именно ответ на ваш вопрос.

Но ужасно плохой идеей определить оператор за пределами пространства имен его параметров (теперь вы сокращаете зависимый от аргумента поиск, который очень удобен для операторов).

Answer 3

Это компиляция, я предполагаю, что без проверки, что она также работает. Обратите внимание на использование скобок:

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() {} 

Как отмечает Александр, хотя, ваш вопрос не объясняет, почему оператор не в пространстве имен NAME. В любом случае его можно назвать 1.0 * some_A_instance. Таким образом, вы можете создать ненужную проблему для себя.

Answer 4

Это возможно - вы можете заключить описатель в скобках: friend A (::operator * (double lhs, const A& rhs));

Вы также должны направить-объявить как класс и функцию.

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) { 
    //... 
} 

Но я согласен с Андреасом в том, что было бы лучше определить как в том же пространстве имен, если это возможно.