C++朋友函数和朋友类

C++朋友函数和朋友类

在本教程中，我们将通过示例学习在 C++ 中创建友元函数和友元类。

数据隐藏是面向对象编程的一个基本概念。它限制了类外部私有成员的访问。

同样，受保护的成员只能由派生类访问，并且无法从外部访问。例如，

class MyClass {
    private:
        int member1;
}

int main() {
    MyClass obj;

    // Error! Cannot access private members from here.
    obj.member1 = 5;
}

但是，C++ 中有一个称为友元函数的特性 打破了这个规则，允许我们从类外访问成员函数。

同样，还有一个朋友类 同样，我们将在本教程的后面部分学习。

C++ 中的朋友函数

好友功能 可以访问private 并且受保护 一个类的数据。我们使用 friend 声明一个友元函数 类主体中的关键字。

class className {
    ... .. ...
    friend returnType functionName(arguments);
    ... .. ...
}

示例1：朋友函数的工作

// C++ program to demonstrate the working of friend function

#include <iostream>
using namespace std;

class Distance {
    private:
        int meter;
        
        // friend function
        friend int addFive(Distance);

    public:
        Distance() : meter(0) {}
        
};

// friend function definition
int addFive(Distance d) {

    //accessing private members from the friend function
    d.meter += 5;
    return d.meter;
}

int main() {
    Distance D;
    cout << "Distance: " << addFive(D);
    return 0;
}

输出

Distance: 5

这里，addFive() 是一个好友函数，可以同时访问private 和公开 数据成员。

虽然这个例子让我们了解了朋友功能的概念，但它并没有显示出任何有意义的用途。

更有意义的用途是对两个不同类的对象进行操作。这时候朋友功能就很有用了。

示例 2：添加两个不同类的成员

// Add members of two different classes using friend functions

#include <iostream>
using namespace std;

// forward declaration
class ClassB;

class ClassA {
    
    public:
        // constructor to initialize numA to 12
        ClassA() : numA(12) {}
        
    private:
        int numA;
        
         // friend function declaration
         friend int add(ClassA, ClassB);
};

class ClassB {

    public:
        // constructor to initialize numB to 1
        ClassB() : numB(1) {}
    
    private:
        int numB;
 
        // friend function declaration
        friend int add(ClassA, ClassB);
};

// access members of both classes
int add(ClassA objectA, ClassB objectB) {
    return (objectA.numA + objectB.numB);
}

int main() {
    ClassA objectA;
    ClassB objectB;
    cout << "Sum: " << add(objectA, objectB);
    return 0;
}

输出

Sum: 13

在这个程序中，ClassA 和 ClassB 已声明 add() 作为朋友功能。因此，这个函数可以访问 private 两个类的数据。

这里要注意的一件事是 ClassA 中的朋友函数 正在使用 ClassB .但是，我们还没有定义 ClassB 此时。

// inside classA 
friend int add(ClassA, ClassB);

为此，我们需要 ClassB 的前向声明 在我们的程序中。

// forward declaration
class ClassB;

C++中的朋友类

我们还可以使用 friend 在 C++ 中使用朋友类 关键词。例如，

class ClassB;

class ClassA {
   // ClassB is a friend class of ClassA
   friend class ClassB;
   ... .. ...
}

class ClassB {
   ... .. ...
}

当一个类被声明为友元类时，友元类的所有成员函数都成为友元函数。

从 ClassB 是一个朋友类，我们可以访问ClassA的所有成员 从 ClassB 内部 .

但是，我们无法访问 ClassB 的成员 从 ClassA 内部 .这是因为 C++ 中的朋友关系只被授予，而不被接受。

示例3：C++朋友类

// C++ program to demonstrate the working of friend class

#include <iostream>
using namespace std;

// forward declaration
class ClassB;

class ClassA {
    private:
        int numA;

        // friend class declaration
        friend class ClassB;

    public:
        // constructor to initialize numA to 12
        ClassA() : numA(12) {}
};

class ClassB {
    private:
        int numB;

    public:
        // constructor to initialize numB to 1
        ClassB() : numB(1) {}
    
    // member function to add numA
    // from ClassA and numB from ClassB
    int add() {
        ClassA objectA;
        return objectA.numA + numB;
    }
};

int main() {
    ClassB objectB;
    cout << "Sum: " << objectB.add();
    return 0;
}

输出

Sum: 13

这里，ClassB 是 ClassA 的朋友类 .所以，ClassB 可以访问 classA 的成员 .

在 ClassB ，我们创建了一个函数add() 返回 numA 的总和 和 numB .

自 ClassB 是一个朋友类，我们可以创建ClassA的对象 ClassB 内部 .