C++的友元函数和友元类
1.什么是友元函数
【1】外部函数访问类内成员
写一个Person类,内部有private、protected、public的三类访问权限的成员
写一个外部函数disp_info来打印这三类成员

总结:可以访问public的,但是protected和private的无法访问
想办法:除非把disp_info挪到Person类内部成为成员函数,否则没办法
【1】外部函数访问类内成员
写一个Person类,内部有private、protected、public的三类访问权限的成员
写一个外部函数disp_info来打印这三类成员
#include <iostream> using namespace std; class person { public: int age; person(){}; person(int age,int height,string name); protected: int height; private: string name; }; //构造函数 person::person(int age,int height,string name) { this->age = age; this->height = height; this->name = name; } //类外的函数 void disp_info(person& pn) { cout << "age = " << pn.age << endl; //public的,类外可以访问 cout << "height = " << pn.height << endl; //protected的,类外不可以访问 cout << "name = " << pn.name << endl; //private的,类外不可以访问 } int main(int argc, char const *argv[]) { person p1(10,155,"jime"); disp_info(p1); return 0; }
总结:可以访问public的,但是protected和private的无法访问
想办法:除非把disp_info挪到Person类内部成为成员函数,否则没办法
【2】友元函数的引入
将外部函数disp_info声明为Person类的友元函数即可解决
class person
{
public:
int age;
person(){};
person(int age,int height,string name);
//声明外部函数为类的友元函数
friend void disp_info(person& pn);
protected:
int height;
private:
string name;
};
【3】总结
- 友元函数不是本类的成员函数,而是一个外部函数
- 友元函数的标志就是在类内部加friend关键字来声明
- 友元函数声明的位置不要求,写在private或者protected或者public内都可以,反正只要有声明就行
- 一个外部函数成为类的友元后,访问权限被扩展了,等同于类的内部成员函数了
- 友元函数是单向的。例如一个类A外部有函数fun(),函数里有一个局部变量i;当fun()函数声明为A的友元函数,意为着fun()函数能访问类A里面的所有权限的成员,而类A却不能访问函数fun()里面的变量i
- 友元函数就好像在类的封装和访问权限保护上打了个“洞”,所以是对面向对象的一种破坏,所以不能滥用
2.友元函数的第二种实现
【1】友元函数的2种实现友元函数为外部函数(上面已经实现)
友元函数为另一个类中的成员函数(也叫友元成员,友元成员方法,友元成员函数)
//- 友元函数为另一个类中的成员函数的实现代码
#include <iostream>
using namespace std;
class person; //类的前置声明
class animal
{
public:
void eat(person& pn); //这里只用到一个person类的引用,不涉及person里面的具体细节,所以能编译通过
};
class person
{
public:
int age;
person(){};
person(int age,int height,string name);
friend void animal::eat(person& pn);
protected:
int height;
private:
string name;
};
//构造函数
person::person(int age,int height,string name)
{
this->age = age;
this->height = height;
this->name = name;
}
void animal::eat(person& pn)
{
cout << "animal eat a person nameed" << pn.name << endl;
cout << "animal eat a person age = " << pn.age << endl;
cout << "animal eat a person height = " << pn.height << endl;
}
int main(int argc, char const *argv[])
{
person p1(10,155,"jime");
animal a1;
a1.eat(p1);
return 0;
}
【2】类的前置声明
- 两个类要互相引用,就会出现“未定义”尴尬,此时可以用前置声明来解决
- 前置声明不包括类的详细信息,所以编译器无法得到前置声明类的大小,成员等详细信息
- 不能试图通过前置声明解决类成员的调用
class animal; //类的前置声明 class person { public: int age; person(){}; person(int age,int height,string name); friend void animal::eat(person& pn); //编译报错,不能通过animal类的前置声明就调用animal里面的eat()成员 protected: int height; private: string name; }; class animal { public: void eat(person& pn); };
不能试图通过前置声明来定义类的对象,只能改为定义类对象的指针或引用。
class person; //类的前置声明 class animal { public: void eat(person& pn); //这里只用到一个person类的引用,不涉及person里面的具体细节,所以能编译通过 //person p1; //不可以 person *p2; //定义成指针和引用都可以 }; class person { public: int age; person(){}; person(int age,int height,string name); friend void animal::eat(person& pn); protected: int height; private: string name; };
3.友元类
【1】友元类的概念和使用#include <iostream> using namespace std; class person; //类的前置声明 class animal { public: void eat(person& pn); void love(person& pn); }; class person { public: int age; person(){}; person(int age,int height,string name); friend class animal; //将animal整个类声明为person类的友元类 protected: int height; private: string name; }; //构造函数 person::person(int age,int height,string name) { this->age = age; this->height = height; this->name = name; } void animal::eat(person& pn) { cout << "animal eat a person nameed" << pn.name << endl; cout << "animal eat a person age = " << pn.age << endl; cout << "animal eat a person height = " << pn.height << endl; cout << endl; } void animal::love(person& pn) { cout << "animal love a person nameed" << pn.name << endl; cout << "animal love a person age = " << pn.age << endl; cout << "animal love a person height = " << pn.height << endl; } int main(int argc, char const *argv[]) { person p1(10,155,"jime"); animal a1; a1.eat(p1); a1.love(p1); return 0; }
-
- 将类animal声明为person中的friend class后,则animal中所有成员函数都成为类person的友元函数了
- 友元类是单向的;2个类可以互为友元类
- 友元类其实就是批量制造友元函数
- 友元类中所有全部成员都成为了友元函数,相当于一次打了很多洞,极大破坏了面向对象
- 除非确实有必要,否则建议按需定义友元函数,尽量维护面向对象,让代码更安全健壮
4.关于友元函数
【1】使用友元函数的优缺点缺点:破坏了封装机制,尽量不使用友元函数,不得已才使用友元函数
优点:在实现类之间数据共享时,减少系统开销,提高效率。
【2】使用友元函数的两种情况
运算符重载的某些场合需要使用友元
两个类要共享数据的时候
【3】运算符重载中使用友元
#include <iostream> using namespace std; class coordinate { public: int x; // x轴坐标 int y; // y轴坐标 coordinate(); coordinate(int x0, int y0); // 拷贝构造函数 coordinate(const coordinate& rhs); void print(void); friend coordinate operator+(const coordinate& a, const coordinate& b); }; coordinate::coordinate() { x = 0; y = 0; }; coordinate::coordinate(int x0, int y0) { x = x0; y = y0; }; // 拷贝构造函数 coordinate::coordinate(const coordinate& rhs) { cout << "---copy construtor---" << endl; this->x = rhs.x; this->y = rhs.y; } void coordinate::print(void) { cout << "(" << this->x << ", " << this->y << ")" << endl; } // 用独立函数来实现+的运算符重载 coordinate operator+(const coordinate& a, const coordinate& b) { coordinate tmp; tmp.x = a.x + b.x; tmp.y = a.y + b.y; return tmp; } int main(void) { coordinate a(1, 3); coordinate b(2, 4); coordinate c; c = a + b; // a+b 就相当于是 c = operator+(a, b); // c = b + a; // 相当于 c = operator+(b, a); a.print(); b.print(); c.print(); return 0; }
并非所有运算符重载都可用友元函数,有四个运算符 =, ->, [], ()就不可以
详解可参考:解析C++中不能重载为友元函数的四个运算符
【4】两个类如何共享数据
- 类内的数据,其实就是类的成员变量
- 2个类共享数据方法1:将共享数据访问权限设置为public。
- 2个类共享数据方法2:通过第三个专门封装数据的类,和2个类中带参数的成员函数来传参共享
- 2个类共享数据方法3:通过友元函数打洞
- 成员函数有this指针,而友元函数没有this指针。为什么?因为友元只是朋友,并不是类内“自家人”
- 友元函数是不能被继承的,就像父亲的朋友未必是儿子的朋友。
- 友元关系不具有传递性。类B是类A的友元,类C是B的友元,类C不一定是类A的友元,要看类中是否有相应的声明
- 1个函数同时成为2个类的友元函数
- 共有友元函数可以是外部函数,也可以是某个(第3个)类的成员函数
- 共有友元函数内可同时访问2个类的受保护成员,间接将2个完全无关的类的数据打通了