友元的语法

使用friend关键字声明友元，friend只要出现在声明处，一个函数或者类作为另一个类的的友元，那么这个函数或类就可以直接访问另一个类的私有数据。

友元重要运用在运算符重载上。

1.普通全局函数成为类的友元

#include<string>
class Room 
{friend void visit1(Room& room);//声明一个友元函数，且为普通全局函数
private:string bedroom;
public:string setingroom;
public:Room(string bedroom, string setingroom){this->bedroom = bedroom;this->setingroom = setingroom;}
};
//普通全局变量
void visit1(Room &room)
{cout << "访问了" << room.bedroom << endl;//可以访问了cout << "访问了" << room.setingroom << endl;
}
int main()
{Room room("卧室", "客厅");visit1(room);//直接调用return 0;
}

2.类的某个成员函数作为另一个类的友元

举例如下：

#include<string>
class Room;//声明类，但是只说明类名称仅此而已
class godgay
{
public:void visiting1(Room& room);void visiting2(Room& room);
};
class Room 
{friend void godgay::visiting2(Room& room);//声明另一个类的函数为该类的友元函数
private:string bedroom;
public:string setingroom;
public:Room(string bedroom, string setingroom){this->bedroom = bedroom;this->setingroom = setingroom;}
};
void godgay::visiting1(Room& room)
{cout << "客人访问问了" << room.setingroom << endl;//cout << "访问了" << room.bedroom << endl;访问不了
}
void godgay::visiting2(Room& room)
{cout << "好基友访问了" << room.bedroom << endl;
}int main()
{Room room("卧室", "客厅");godgay a;a.visiting2(room);//直接调用a.visiting1(room);return 0;
}

我们将一个类中的函数声明为另一个类中的友元函数，该友元函数便可以访问该类中的私有数据。

在这里我们需要注意类的声明，类的声明只是说有个这个名字的类，但此时类的成员未定义，引用会报错，我们需要再定义类，之后再访问。

整个类作为另一个类的友元

class Building;class Goodgay{
public:Goodgay(string hall, string bedroom);void visit();Building * b;};class Building{//friend void print_Building(Building &b);//friend class Goodgay; //一个类成为另一个类的友元friend void Goodgay::visit();//类的成员函数成为另一类的友元public:Building(string hall, string bedroom){this-> bedroom = bedroom;this-> hall = hall;}string hall;private:string bedroom;};Goodgay::Goodgay(string hall, string bedroom){b = new Building(hall, bedroom);}void Goodgay::visit(){cout << b-> hall << " " << b-> bedroom << endl;}void test01(){Goodgay gd("卧龙山庄", "闺房");gd.visit();}int main()
{test01(); return 0;}

将一个类作为友元，即类中的任何成员都可以访问该私有数据。

注意事项：

1.友元关系不能被继承

2.友元关系是单向性的

3.友元关系不具有传递性

运算符重载

1 运算符重载的基本概念

2 重载加号运算符

class person{public:person(int age){this-> age = age;}person operator+(person & p2){person p(this->age + p2.age);return p;}int age;};//person operator+(person &p1, person &p2)
//{// person p(p1.age+p2.age);// return p;//}void test01(){person p1(10);person p2(20);person p3 = p1 + p2;// operator+(p1,p2) p1.operator+(p2)cout << p3.age << endl;}int main(){test01();return 0;
}

 在这里我们也可以自己定义一个operator+的运算符，可以将两个类中的age相加。

3 重载左移运算符和算符重载碰上友元函数

class person{friend ostream & operator<<(ostream & cout, person & p);public:person(int age){this-> age = age;}private:int age;};
ostream & operator<<(ostream & cout, person & p){cout << p.age;return cout;}void test01(){person p1(10);cout << p1 << endl;// operator<<(cout,p1) //cout.operator<<(p1)	重载左移运算符}int main(){test01();return 0;}

这里的ostream&opeator<<是一个插入格式化输出函数。 

可以重载的运算符