Làm cách nào để xác định bạn bè trong không gian tên chung trong một không gian tên C++ khác?

Question

Tôi muốn xác định toán tử nhị phân trong không gian tên chung. Toán tử hoạt động trên một lớp được xác định trong một không gian tên khác và toán tử sẽ nhận được quyền truy cập vào các thành viên riêng tư của lớp đó. Vấn đề tôi có là tôi không biết cách phạm vi toán tử toàn cục đó khi biến nó thành một người bạn trong định nghĩa lớp.

tôi đã cố gắng một cái gì đó như:

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

Trình biên dịch (g ++ 4.4) không biết phải làm gì với nó. Dường như dòng

friend A ::operator *() 

được đánh giá là một cái gì đó tương tự (pseudo-code)

(A::operator) 

thay vì

(A) (::operator) 

Nếu tôi bỏ qua :: trong việc kê khai của điều hành các công việc biên dịch nhưng toán tử sau đó nằm trong không gian tên NAME và không nằm trong không gian tên chung.

Làm cách nào để tôi có thể đủ điều kiện cho không gian tên chung trong tình huống như vậy?

Answer 1

Đầu tiên, lưu ý rằng tuyên bố điều hành của bạn còn thiếu một bằng cấp không gian tên cho A:

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

và sau đó lừa quyết định là thêm dấu ngoặc đơn để kê khai người bạn như thế này, cũng giống như bạn đề xuất trong "pseudo của bạn -code"

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

Để làm cho nó tất cả các biên dịch, sau đó bạn cần một số tờ khai về phía trước, đến lúc này:

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 là đúng, mặc dù - bạn có lẽ nên khai báo toán tử trong cùng một không gian tên như các tham số của nó.

Answer 2

Tôi không biết câu trả lời chính xác cho câu hỏi của bạn.

Nhưng đó là ý tưởng tồi tệ để xác định toán tử bên ngoài không gian tên của các tham số của nó (bây giờ bạn cắt tìm kiếm đối số phụ thuộc rất dễ sử dụng cho toán tử).

Answer 3

Biên dịch này, tôi giả định mà không thử nghiệm rằng nó cũng hoạt động. Lưu ý việc sử dụng dấu ngoặc đơ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) 
{ 
    double x = rhs.private_var; 
    return rhs; 
} 

int main() {} 

Vì Alexander đề cập, câu hỏi của bạn không giải thích tại sao toán tử không nằm trong không gian tên NAME. Dù bằng cách nào, nó có thể được gọi là 1.0 * some_A_instance. Vì vậy, bạn có thể tạo ra rắc rối không cần thiết cho chính mình.

Answer 4

Có thể - bạn có thể kèm theo declarator trong ngoặc đơn: friend A (::operator * (double lhs, const A& rhs));

Bạn cũng cần để chuyển tiếp-tuyên bố cả hai lớp và hàm.

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

Nhưng tôi đồng ý với Andreas rằng sẽ tốt hơn nếu xác định cả hai trong cùng một không gian tên nếu có thể.