C++面向对象（OOP）编程-友元（友元函数和友元类）

发狂的小花

已于 2023-12-28 15:51:38 修改

阅读量1k

点赞数 16

分类专栏： # C/C++精进之路 C/C++编程集合文章标签： c++ 开发语言算法友元

于 2023-12-13 19:46:35 首次发布

本文链接：https://blog.csdn.net/m0_47324800/article/details/134979732

版权

C/C++编程集合同时被 2 个专栏收录

36 篇文章 0 订阅

订阅专栏

C/C++精进之路

19 篇文章 3 订阅

订阅专栏

本文主要介绍面向对象编程的友元的使用，以及友元的特性和分类，提供C++代码。

🎬个人简介：一个全栈工程师的升级之路！
📋个人专栏：C/C++精进之路
🎀CSDN主页发狂的小花
🌄人生秘诀：学习的本质就是极致重复!

1 为什么引进友元

面向对象编程（OOP）的三大特性中的封装，是通过类实现对数据的隐藏和封装。一般定义类的成员变量为私有成员，成员函数为公有函数，通过公有函数作为类的接口实现与外部交互。一些情况下，类外的某些函数需要频繁访问类的成员变量，因此引入了友元的概念，将类外的函数定义为该类的友元函数，从而实现对该类私有成员的访问。由此，还引入友元类，就是一个类是另一个类的友元类，友元类可以访问另一个类的所有成员。友元函数和友元类称为友元。

友元的作用是提高了程序的运行效率（减少了类型检查和安全检查的耗时），但是友元破坏了类的封装和隐藏性，让非类成员函数可以类的私有成员。

友元是C++语言中的一种关系，友元关系发生在函数与类之间或者类与类之间。友元关系是单向的，不能传递。

与类有友元关系的函数称为友元函数，与类有友元关系的类称为友元类。

2 友元的性质

（1）在被访问类中以friend关键字修饰友元类或者友元函数

（2）友元不属于该类，且不受该类的访问限制，可以直接访问具体类的所有成员

（3）友元关系不能被继承

（4）友元关系是单向的，不具有交换性，只能是一个函数访问一个类的所有成员，或者一个类允许访问另一个类的所有成员，反之不行

（5）友元关系不具有传递性

3 友元的本质

友元的本质是提供不属于该类成员，包括全局函数、其他类的成员函数、其他类，访问本类所有成员和成员属性的属性。

4 友元分类

4.1 全局函数为友元函数

全局函数拥有访问一个类所有成员的能力，需要在被访问类中用关键字friend声明f被访问类的友元函数。一个类可以拥有多个友元函数。一个函数也可以是多个类的友元函数。

代码如下：

#include <iostream>
#include <string>
using namespace std;

class A
{
    private:
        string name_;
        int age_;
    public:
        A(const string name,const int age) : name_(name), age_(age) {cout << "A构造函数 初始化参数" << endl;};
        virtual ~A()
        {
            cout << "A析构函数 " << endl;
        }
        void func()
        {
            std::cout << "A's func()" << std::endl;
        }

        
        friend void get_members_global(A & a);  // 友元全局函数，可以访问A的私有成员变量和所有的公有成员
        
};

// 全局函数作为友元函数
void get_members_global(A & a)
{
    cout << a.name_ << " is " << a.age_ << " years old " << endl;
    a.func();
}


int main()
{
    A a("Hubery",45);

    cout << "***************************全局函数作为友元函数***************************" << endl;

    get_members_global(a);

    return 0;
}

运行结果：

4.2 类的成员函数为友元函数

类成员函数作为类的友元声明时只需在友元的名称前加上关键字friend，其格式如下：

friend 类型类名::函数名(形式参数);

一个函数可以是多个类的友元函数，只需要在各个类中分别声明。

代码如下：

#include <iostream>
#include <string>
using namespace std;

class A;

class C
{
    public:
        //类的成员函数作为友元函数
        void get_members_member(A &a);
        C()
        {
            cout << "C构造函数" << endl;
        }
        ~C()
        {
            cout << "C析构函数" << endl;
        }
};

class A
{
    private:
        string name_;
        int age_;
    public:
        A(const string name,const int age) : name_(name), age_(age) {cout << "A构造函数 初始化参数" << endl;};
        virtual ~A()
        {
            cout << "A析构函数 " << endl;
        }
        void func()
        {
            std::cout << "A's func()" << std::endl;
        }

        friend void C::get_members_member(A &a); // C的成员函数做友元函数，可以访问所有成员
        
};

// 类的成员函数作为友元函数
void C::get_members_member(A &a)
{
    cout << a.name_ << " is " << a.age_ << " years old " << endl;
    a.func();
}

int main()
{
    A a("Hubery",45);
    C c;

    cout << "***************************类的成员函数作为友元函数***************************" << endl;

    c.get_members_member(a);

    return 0;
}

运行结果：

这里用到类的前向声明。前向声明，是一种不完全型（forward declaration）声明，即只需提供类名(无需提供类实现)即可。前向声明功能有限:
(1）不能定义类的对象。
（2）可以用于定义指向这个类型的指针或引用。
（3）用于声明(不是定义)使用该类型作为形参或者返回类型的函数。

4.3 类作为友元

友元类的所有成员函数都是另一个类的友元函数，都可以访问另一个类中的隐藏信息（包括私有成员和保护成员）。当希望一个类可以访问另一个类的私有成员、保护成员时，可以将该类声明为另一类的友元类。

定义友元类的语句格式如下：

friend class 类名;
friend和class是关键字，类名必须是程序中的一个已定义的类。

代码如下：

#include <iostream>
#include <string>
using namespace std;

class B; // 前向声明

class A
{
    private:
        string name_;
        int age_;
    public:
        A(const string name,const int age) : name_(name), age_(age) {cout << "A构造函数 初始化参数" << endl;};
        virtual ~A()
        {
            cout << "A析构函数 " << endl;
        }
        void func()
        {
            std::cout << "A's func()" << std::endl;
        }
        friend class B; // 声明B为A的友元类，B中成员函数可以访问A中所有的成员
        
};

class B
{
    private:
        string name_;
        int age_;
    public:
        B(const string name,const int age) : name_(name), age_(age) {cout << "B构造函数 初始化参数" << endl;};
        virtual ~B()
        {
            cout << "B析构函数 " << endl;
        }
        void func()
        {
            std::cout << "B's func()" << std::endl;
        };
        // 友元类
        void get_members_class(A & a)
        {
            cout << a.name_ << " is " << a.age_ << " years old " << endl;
            a.func();
        };

};


int main()
{
    A a("Hubery",45);
    B b("Tom",24);

    cout << "***************************友元类***************************" << endl;
    b.get_members_class(a);

    return 0;
}

运行结果：