我可以在C++中执行以下操作：

Question

我有两个类，即X和Y;

 X         Y 

    foo ()       bar () 

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

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

即Y具有在未经许可的仅到达X对象的foo功能？

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

Answer 1

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

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

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

Answer 2

如果我理解你的问题正确的话，你想是这样的：

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