c++基础知识：友元

c++基础知识：友元

友元，这是一种在C++编程语言中定义的访问权限规则。它使得程序的某些部分能够访问类的私有和保护成员。友元允许一个类中的非成员函数和其他类的成员函数访问该类的私有成员。在这篇博客中，我们将深入探讨关于友元的概念、类型、用法、案例、以及注意事项。

一、概念

友元的目的是让一个函数或者类，访问另一个类中的私有成员。在声明中使用关键字friend即可将函数或类声明为友元。通过这样的方式，在一定程度上改变了访问权限。

二、类型

有三种不同类型的友元：全局函数（非成员函数）、非成员类、成员函数。

1. 全局函数（非成员函数）
   例如，一个在类外定义的函数需要直接访问类的某些私有成员，那么就可以将这个函数声明为该类的友元函数。这样该函数就可以直接访问该类的私有成员变量和私有函数。这种友元的定义方式为：友元 函数类型 函数名。

2. 类友元
   如果在一个类中存在另一个类的成员变量，则需要将这个类声明为该类的友元类。这样该类的所有成员函数都可以直接访问该类的私有成员变量和私有函数。

3. 成员函数友元
   如果类中的一个成员函数需要直接访问另一个对象的私有成员变量，可以将这个函数声明为另一个类的成员函数，并且将该类声明为友元类。这种情况下，只有该类的特定成员函数可以访问另一个类的私有成员变量以及函数，其他成员函数仍然不能访问这些变量和函数。

三、案例用法

友元的主要作用是允许某些特定的函数或类能够访问一个类中的私有和保护成员。友元的作用类似于全局变量的概念，能够更加方便的在不同的函数或类之间共享信息。

下面我们就来看看三种友元的案例，来解释友元的实际用法。

demo1 全局函数（非成员函数）友元

全局函数globalFunc()访问Building类的私有成员

#include<iostream>
#include<string>
#include<stdio.h>
using namespace std;
/*
*/
class Building
{
//全局函数globalFunc()访问Building类的私有成员
    friend void globalFunc(Building *building);

public:
    Building()
    {
        livingRoom = "客厅";
        bedRoom = "卧室";
    }
    string livingRoom;

private:
    string bedRoom;

};

void globalFunc(Building *building)
{
    cout << "全局访问" << building->livingRoom << endl;
    cout << "全局访问" << building->bedRoom << endl;
}
void test01()
{
    Building building;
    globalFunc(&building);
}

int main()
{
    test01();
    return 0;
}

demo2 类友元

Friend类可以访问Building类的私有成员

#include<iostream>
#include<string>
#include<stdio.h>
using namespace std;

/*
类做友元
*/
class Building;
class Friend{

public:
    Friend();

    Building *building;
    void visit();

private:

};

class Building{
    //加上friend关键字  Friend类可以访问本类的私有成员
	friend class Friend;

public:
    Building();

    string livingRoom;

private:
    string bedRoom;


};

//类外写成员函数

Building::Building()
{
    livingRoom = "客厅";
    bedRoom = "卧室";
}

Friend::Friend()
{
    building = new Building;
}

void Friend::visit()
{
    cout << "类访问" << building->livingRoom << endl;
    cout << "类访问" << building->bedRoom << endl;

}

void test()
{
    Friend ee;
    ee.visit();
}

int main()
{
    test();

    return 0;
}

demo3 成员函数友元

Friend类下的visitPrivate(),可以访问Building类的私有成员

#include<iostream>
#include<string>
#include<stdio.h>
using namespace std;

/*
成员函数做友元
*/
class Building;

class Friend{
public:
    Friend();

    void visitPrivate();
    void visit();
    Building *building;
};

class Building{
    //Friend类下的visitPrivate(),可以访问本类的私有成员
    friend void Friend::visitPrivate();
public:
    Building();
    string livingRoom;

private:
    string bedRoom;
};

Friend::Friend()
{
    building = new Building;
}

Building::Building()
{
    livingRoom = "客厅";
    bedRoom = "卧室";
}

void Friend::visit()
{
    cout << "成员函数访问公共" << building->livingRoom << endl;
    //cout << "成员函数访问公共" << building->bedRoom << endl;
}

void Friend::visitPrivate()
{
    cout << "成员函数访问公共" << building->livingRoom << endl;
    cout << "成员函数访问" << building->bedRoom << endl;

}

void test()
{
   Friend gg;
   gg.visit();
   gg.visitPrivate();
}

int main()
{
    test();

    return 0;
}

四、注意事项

使用友元可以改变类的访问控制，但是需要注意以下几点：

1. 降低封装性：友元可以访问类的私有成员变量和私有函数，这可能会降低类的封装性。

2. 破坏类的继承：如果一个类A是另一个类B的友元，则类B的派生类不能访问类A的私有成员，这可能会破坏类的继承。

3. 避免滥用：友元还是需要谨慎使用，仅在必要的时候使用。如果过度使用友元，就会导致程序难以维护。

五、总结

通过本文，我们了解了友元的概念、类型、用法、案例和注意事项。友元是一种可以很好地辅助类进行访问控制的工具。我们可以通过友元更好地满足程序设计的需求，并且能够提高代码的可读性和可维护性。但是，友元也需要我们谨慎使用，注意保持类的封装性，并且避免滥用。