如何在另一个 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;
    ...
}

编译器（g++ 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

这可以编译，我假设没有测试它也可以工作。请注意括号的使用：

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

不过，正如 Alexander 提到的，您的问题没有解释为什么运算符不在命名空间 NAME 中。无论哪种方式，它都可以被称为 1.0 * some_A_instance。所以你可能会给自己制造不必要的麻烦。

Answer 3

我不知道你的问题的确切答案。

但是在其参数的名称空间之外定义运算符是一个非常糟糕的主意（现在您可以删除对运算符非常有用的参数依赖查找）。

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

但我同意 Andreas 的观点，如果可能的话，最好将两者定义在同一个命名空间中。