8

是否可以？

class sample {
        private:
           int x;
        public:
           friend void fun();
};

friend没有参数的函数！

在我看来不可能

因为友元函数不是类的“成员”所以我们不能用类对象调用

像：

sample s;
s.fun();
4

9 回答 9

16

是的你可以：

void fun()
{
  sample s;
  s.x++;   // OK, fun() is a friend of sample
}

或者

sample globalSample; // yikes, a global variable

void fun()
{
  int i = globalSample.x; // OK, fun() is a friend of sample
}
于 2013-07-30T08:24:02.640 回答
6

是的你可以。这可能有很多原因，例如访问私有静态成员或者可能存在sample. 也可以fun创建一个实例sample并获取它的私有数据。

函数创建实例并用它做事的工作示例：

#include <iostream>
class sample {
    private:
       int x;
    public:
       friend void fun();
};

void fun()
{
    sample s;
    s.x = 555555555;
    std::cout << s.x;
}
int main(){
    fun();
    return 0;
}

具有全局实例的示例：

#include <iostream>
#include <string>
class sample {
    private:
       int x;
    public:
       friend void fun();
};
sample s;

void fun()
{

    s.x = 555555555;
    std::cout << s.x;
}
int main(){
    fun();
    return 0;
}

私有静态成员的示例：

#include <iostream>
#include <string>
class sample {
    private:
       int x;
       static const int w = 55;
    public:
       friend void fun();
};


void fun()
{

    std::cout << sample::w;
}
int main(){
    fun();
    return 0;
}
于 2013-07-30T08:28:25.120 回答
5

当然你可以..看到这里的示例代码。但是要定义内联函数，您需要使用sampleas 参数，否则 ADL 将不起作用，编译器将无法解析func. 在此处查看示例。

于 2013-07-30T08:26:24.780 回答
3

可以有没有参数的友元函数。您需要另一种访问类样本对象的方法。别忘了，友元函数还允许您访问类示例的私有静态变量，以备不时之需

于 2013-07-30T08:26:09.667 回答
2

是的，但是对于变量，您将需要它们是全局的。sample在您的情况下，类型的全局对象。或者在可能的定义中在函数内部创建对象fun()。

sample globalObject;

void fun()
{
 globalObject.x++;   //this will work as fun() is friend function of sample.
}
于 2013-07-30T08:24:24.663 回答
1

当然这是可能的。您似乎想知道为什么有人会这样做。例如，它可以访问静态私有成员变量。或者它可以通过某种方式访问​​它获得的对象的私有成员（单例，全局（容器）对象，...）

于 2013-07-30T08:26:16.753 回答
1

有一个没有参数的友元函数是可能的。它很少使用。

于 2013-07-30T08:28:31.617 回答
0 
sample s;
s.fun();

这无论如何都行不通，因为 C++ 中的“友谊”只是解除了对私有/受保护成员的访问限制。朋友不是班级成员，因此您无法调用 s.fun()。

但是，您可以像描述的那样声明一个朋友函数，并且从该函数中您将可以访问示例类的私有成员。

于 2013-07-30T08:34:50.413 回答
0

朋友方法可能很有用，因为这种对私有/受保护数据成员的访问仅限于那些指定的方法。这个方法是否有参数或返回类型并不重要。

template <class T>
class CLinkedListNode {
public:
    CLinkedListNode(CLinkedList<T>* Parent) : _Parent(Parent) {
    }
protected:
    CLinkedListNode * _Next;
    T _Data;
    CLinkedList<T>* _Parent;

    friend CLinkedListNode<T>* CLinkedList<T>::find(); // Only CLinkedList<T>::find() may access data members
    friend void sort(); // All sort methods may access data members
};

所以想象有一个类 CLinkedList，它的find()方法能够访问 CLinkedListNode 的所有数据成员。

template <class T>
class CLinkedList {
// ...
    CLinkedListNode<T>* find() {
        CLinkedListNode<T>* Node = new CLinkedListNode<T>(this);
        CLinkedListNode<T>* Find = Node->_Next;
        while (Find->_Next) {
            // Do something
            Find = Find->_Next;
        }
        // ...
        return Node;
    }
};
于 2013-07-30T08:54:00.457 回答