Question

我有两个类，即X和Y;

       X                                  Y 

    foo ( )                           bar ( )

Y仅在X类中使用foo函数。我可以在c ++中执行以下操作吗？

friend bool Y :: bar ( X & (X :: foo) )

那是Y只允许foo 对象的X功能？

编辑：X & (X :: foo)用法是否正确？

Answer 1

如果我理解你的问题是正确的，你需要这样的东西：

class X;

class Y {
public:
    void bar(X& x);
    void baz(X& x);
};

class X {
    void foo() { }
    friend void Y::bar(X& x);
};

void Y::bar(X& x)
{
    x.foo();
}

void Y::baz(X&)
{
    // the following would be an error
    // baz wasn't befriended with X
    // x.foo();
}

int main()
{
    X x;
    Y y;
    y.bar(x);
}

请注意声明和定义的顺序，您需要这样做，以便您可以在X内Y::bar()实际创建有用的内容。

但是，如果没想到这样做是个好主意的情况。如果你失败了，你只需要与你的课程的“部分”成为朋友，那么你的课程可能会承担太多的责任。

Answer 2

不，你不能。但是你可以做到以下几点：

class X_foo_friend;

class X
{
    void foo();
    friend class X_foo_friend;
};

class Y
{
    X x;
public:
    void bar();
};

class X_foo_friend
{
    static void foo(X& x);
    friend void Y::bar();
};

void X::foo() {};
void X_foo_friend::foo(X & x) { x.foo(); }

void Y::bar()
{
    X_foo_friend::foo(x);
}

IMO，这是相当愚蠢的。我的意思是，你是设计X和Y的人，所以你可以简单地限制你在Y的X函数中的使用。

Answer 3

我可能会探讨使用ADL概念的中间代理。这当然是显示概念的部分实现。

namespace XNProxy {
    class XNP;
}

namespace XN
{
    using XNProxy::XNP;

    class X {
        friend void f(X *);
    private:
        void foo() { };
    };

    void f(X* p) {
        X x;
        x.foo();
    }
}

namespace XNProxy 
{
    class XNP { };
    using XN::X;
    void f(XNP *) {
        f((XN::X *)nullptr);
    }
};

namespace YN
{
    class Y {
    public:
        void bar() { 
            XNProxy::XNP x;
            f((XNProxy::XNP*)nullptr);
        }
    };
}

int main() {
    YN::Y y;
    y.bar();
}

我可以在c ++中执行以下操作

3 个答案: