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

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注意声明和定义的顺序，你需要这样，这样你就可以用inside做一些有用的东西Y::bar()。

但是，如果没有想到这样做是个好主意的情况。如果你跌倒了，你只需要和你的班级的“部分”交朋友，那么你的班级可能有太多的责任。

Answer 2

我可能会使用 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();
}

Answer 3

你不能。但您可以执行以下操作：

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 的人，所以你可以简单地限制你在 X 的 Y 函数中的使用。