先看代码

// 友元函数

// 你是它的好朋友，那就可以拿私有成员给好朋友

#include <iostream>

using namespace std;

class Person {
private: // 私有的age，外界不能访问
    int age = 0;

public:
    Person(int age) {
        this->age = age;
    }

    int getAge() {
        return this->age;
    }

    // 定义友元函数 (声明，没有实现)
    friend void updateAge(Person * person, int age);
};

// 友元函数的实现，可以访问所以私有成员
void updateAge(Person* person, int age) {
    // 默认情况下：不能修改 私有的age
    // 谁有这个权限：友元（拿到所有私有成员）
    person->age = age;
}

int main() {
    Person person = Person(9);
    updateAge(&person, 88);

    cout << person.getAge() << endl;
    return 0;
}

① 【你是它的好朋友，那就可以拿私有成员给好朋友】
② 【定义友元函数，然后，友元函数的实现，可以访问所以私有成员】

一个相对正规的例子

头文件

#include <iostream>

using namespace std;


#ifndef PIG_H // 你有没有这个宏（Java 宏==常量）
#define PIG_H // 定义这个宏

class Pig {
private:
    int age;
    char * name;

public:
    // 静态成员声明
    static int id;

    // 构造函数的声明系列
    Pig();
    Pig(char *);
    Pig(char *,int);

    // 析构函数
    ~Pig();

    // 拷贝构造函数
    Pig(const Pig & pig);

    // 普通函数 set get
    int getAge();
    char * getName();
    void setAge(int);
    void setName(char *);

    void showPigInfo() const; // 常量指针常量 只读

    // 静态函数的声明
    static void changeTag(int age);

    // 不要这样干
    // void changeTag(int age);

    // 友元函数的声明
    friend void changeAge(Pig * pig, int age);
};

#endif // 关闭/结尾

实现和使用

#include "Pig.h"

// TODO  ======================  下面是 普普通通 常规操作 对象::

// 实现构造函数
Pig::Pig() {
    cout << "默认构造函数" << endl;
}

Pig::Pig(char * name) {
    cout << "1个参数构造函数" << endl;
}

Pig::Pig(char * name, int age) {
    cout << "2个参数构造函数" << endl;
}

// 实现析构函数
Pig::~Pig() {
    cout << "析构函数" << endl;
}

// 实现 拷贝构造函数
Pig::Pig(const Pig &pig) {
    cout << "拷贝构造函数" << endl;
}

int Pig::getAge() {
    return this->age;
}
char * Pig::getName() {
    return this->name;
}
void Pig::setAge(int age) {
    this->age = age;
}
void Pig::setName(char * name) {
    this->name = name;
}

void Pig::showPigInfo() const {

} // 常量指针常量 只读

// ===============================  静态 和 友元 

// 实现 静态属性【不需要增加 static关键字】
int Pig::id = 878;

// 实现静态函数，【不需要增加 static关键字】
void Pig::changeTag(int age) {

}

// 友元的实现
// 友元特殊：不需要关键字，也不需要 对象:: ,只需要保证 函数名（参数）
void changeAge(Pig * pig, int age) {

}

延伸思考

// 友元类 （ImageView 私有成员  可以通过Class来访问，但是Class操作的native C++代码）
// ImageView 私有成员  你能访问它的私有成员吗 Class
#include <iostream>

using namespace std;

class ImageView {
private:
    int viewSize;
    friend class Class; // 友元类
};

// Java每个类，都会有一个Class，此Class可以操作 ImageView私有成员（感觉很神奇）
class Class {
public:
    ImageView imageView;

    void changeViewSize(int size) {
        imageView.viewSize = size;
    }

    int getViewSize() {
        return imageView.viewSize;
    }
};

int main() {
    Class mImageViewClass;

    mImageViewClass.changeViewSize(600);

    cout << mImageViewClass.getViewSize() << endl;

    return 0;
}

我们操作java代码，有很多时候有native的方法声明，需要下载 JDK native代码 才能看到，也是这个道理。
为什么java 能修改私有属性，底层C++ 友元的相关类似操作。