C++中的友元函数主要应用于以下场景：
友元函数
第一种场景
代码中有一个全局函数，该函数想要去访问某个类的成员变量(该类的成员变量是private的，且该类并未提供任何获取获取私有成员变量的public方法)，这时候可以在这个类中把该全局函数声明为友元函数，这样这个全局函数就具备了能够获取那个类的私有成员变量的资格。
例：通过友元函数获取Person类的各项字段信息：
main.cpp
#include <iostream>
#include "Person.h" void showPersonInfo(Person *person)
{
std::cout << person->m_name << ", age is: " << person->m_age << ", sex is: " << person->m_sex << std::endl;
}
int main()
{
Person *person = new Person("xp.chen", 20, 1);
showPersonInfo(person);
delete person; getchar();
return 0;
}
person.h
#pragma once
class Person
{
private:
char *m_name;
int m_age;
int m_sex;
public:
Person(char *name, int age, int sex);
~Person();
public:
friend void showPersonInfo(Person *person); // 将showPersonInfo()函数声明为友元函数
};
person.cpp
#include "Person.h" Person::Person(char *name, int age, int sex)
:m_name(name)
, m_age(age)
, m_sex(sex)
{
} Person::~Person()
{
}
运行结果：
xp.chen, age is: 20, sex is: 1
第二种场景
在某个类(假设为A类)有一个成员函数，该成员函数想去访问另一个类(假设为B类)中的私有成员变量。这时候则可以在第二个类(B类)中，声明第一个类(A类)的那个成员函数为友元函数，这样第一个类(A类)就可以访问第二个类(B类)的私有成员变量了。
例：打印Person类的详细信息(包含姓名,年龄，性别，省份，城市，街道)
Person.h
#pragma once class Address;
class Person
{
private:
char *m_name;
int m_age;
int m_sex;
public:
Person(char *name, int age, int sex);
~Person();
public:
void showDetailInfo(Address *addr); // 用于打印包含姓名,年龄，性别，省份，城市，街道的详细信息
};
Address.h
#pragma once
#include "Person.h" class Address
{
private:
char *m_province;
char *m_city;
char *m_district; public:
Address(char *province, char *city, char *district);
~Address();
public:
friend void Person::showDetailInfo(Address *addr);
};
Address.cpp
#include "Address.h" Address::Address(char *province, char *city, char *district)
:m_province(province)
, m_city(city)
, m_district(district)
{
} Address::~Address()
{
}
Person.cpp
#include <iostream>
#include "Address.h" Person::Person(char *name, int age, int sex)
:m_name(name)
, m_age(age)
, m_sex(sex)
{
} void Person::showDetailInfo(Address *addr)
{
std::cout << "Name: " << m_name << ", Age: " << m_age << ", Sex: " << m_sex << ", Province: " << addr->m_province << ", City: " << addr->m_city << ", District: " << addr->m_district << std::endl;
} Person::~Person()
{
}
main.cpp
#include <iostream>
#include <stdlib.h>
#include "Address.h" int main()
{
Person *person = new Person("xp.chen", , );
Address *address = new Address("JS", "KS", "ZhengRoad");
person->showDetailInfo(address); delete person, address;
system("pause");
return ;
}
运行结果：
Name: xp.chen, Age: 20, Sex: 1, Province: JS, City: KS, District: ZhengRoad
友元类
友元类则更简单，可以将一个类(类A)声明成另一个类(类B)的友元类，那么类A就拥有了能够访问类B所有成员的资格，包括private, protected, public的。
例：将上述例子中的Address.h修改成：
#pragma once
#include "Person.h" class Address
{
private:
char *m_province;
char *m_city;
char *m_district; public:
Address(char *province, char *city, char *district);
~Address();
public:
friend class Person;
};
声明类Person是类Address的友元类，再次运行程序：
Name: xp.chen, Age: 20, Sex: 1, Province: JS, City: KS, District: ZhengRoad
需要注意的是：
- 友元的关系是单向的而不是双向的。如果声明了类 B 是类 A 的友元类，不等于类 A 是类 B 的友元类，类 A 中的成员函数不能访问类 B 中的 private 成员。
- 友元的关系不能传递。如果类 B 是类 A 的友元类，类 C 是类 B 的友元类，不等于类 C 是类 A 的友元类。
另外，有的编译器也可以不写class关键字，也就是说可以写成：friend Person, 不过为了兼容性还是建议写上。