4.4 友元

4.4 友元

在程序里，有些私有属性 也想让类外特殊的一些函数或者类进行访问，就需要用到友元的技术

友元的目的是让一个函数或者类 访问另一个类中的私有成员

友元的关键字为 friend

友元的三种使用场景

• 全局函数做友元
• 类做友元
• 成员函数做友元

4.4.1 全局函数做友元

友元函数的声明在类内，但定义在类外。友元函数的声明中需要使用 friend 关键字。

#include <iostream>

class Person {
public:
    Person(int data) : p_age(data) {}

    // 类内声明友元函数
    friend void FriendFunction(const Person& p);
    
private:
    int p_age;
};

// 定义友元函数（友元函数的定义在类定义后）
void FriendFunction(const Person& p) {
    // 友元函数可以访问类的私有成员
    std::cout << "Private data in MyClass: " << p.p_age << std::endl;
}

void test01()
{
    //使用Person实例化一个对象
    Person p1(25);
    // 调用友元函数
    FriendFunction(p1);
}

int main() {


    return 0;
}

上面代码中使用了成员初始化列表。

Person(int data) : p_age(data) {} 

代码是 Person 类的构造函数的实现。这个构造函数接受一个整数参数 data，并用成员初始化列表将参数的值赋给类的私有成员变量 p_age。和下面的代码作用是一样的

Person(int data) {
    p_age = data; // 在构造函数体中使用赋值语句进行初始化
}

运行结果

4.4.2 类做友元

将一个类声明为另一个类的友元。这样，友元类就能够访问其它类的私有成员。

假设一个人的年龄是私有数据，不想让别人知道。但是他的好朋友可以知道。

#include <iostream>

//要声明一下Person类，因为在Tom类里有使用到
class Person;

class Tom {
public:
    //声明一个函数查看好朋友的年龄，定义要在Person类的定义后
    void accessPrivateDate(const Person &p);

};

class Person {
public:
    //有参构造，使用成员初始化列表，为p_age赋值
	Person(int age):p_age(age){
       
	} 
	
    //在类内声明一个友元类
    friend class Tom;
private:
    //设置年龄是私有的，一般人不让访问，好朋友可以
    int p_age;

};

//这个函数的定义要在Person类定义之后。
void Tom::accessPrivateDate(const Person &p)
{
    //好朋友(友元类)访问Person类的私有数据
    std::cout <<"Person private data:" << p.p_age << std::endl;
}


void test01()
{   
    Person p1(25);
    
    Tom tom;
    //使用友元类的成员函数访问Person类的私有数据
    tom.accessPrivateDate(p1);

}

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

对于Tom类的成员函数，为什么不能定义在类内那？

如果 Tom 类的成员函数 accessPrivateDate 是在 Person 类定义之前定义的， Person 类在 Tom 类中是不完全类型，编译报错不过。所以提供一个外部定义来实现 accessPrivateDate，或者将Tom 类的定义移到 Person 类定义之后。

运行结果如下：

4.4.3 成员函数做友元

类的成员函数可以在类的定义之后定义，但是不能在类的定义之前声明为友元。友元的声明必须在类的定义之内。

#include <iostream>

// 提前声明Person类
class Person;

class Tom {
public:
    // 在Tom类内声明Person类的成员函数为友元
    void accessPrivateDate(const Person &p);
};

class Person {
public:
    // 有参构造，使用成员初始化列表，为p_age赋值
    Person(int age) : p_age(age) {}

    // 在类内声明。Tom类的成员函数做友元函数
    friend void Tom::accessPrivateDate(const Person &p);

private:
    // 设置年龄是私有的，一般人不让访问，好朋友可以
    int p_age;
};

// 在Person类定义之前，提供Tom类的完整定义
void Tom::accessPrivateDate(const Person &p) {
    // 访问Person类的私有数据
    std::cout << "Person private data:" << p.p_age << std::endl;
}

void test01() {
    Person p1(28);

    Tom tom;
    // 使用友元类的成员函数访问Person类的私有数据
    tom.accessPrivateDate(p1);
}

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

上面的代码有两个注意的地方

1.要将Tom类的定义放在Person类的定义之前

因为要在Person类内将Tom类的成员函数做一个友元函数声明。声明之前需要将

2.Tom类的成员函数为什么要放在类外实现

Tom类的成员函数，访问了Person类内的私有属性的成员(p_age)所以函数要定义在Person类定义之后。再由于上面1的原因，就造成了Tom类成员函数的类外实现。

运行结果如下：