C++ 友元关系

在C++中，当基类A，给与属性protected限定时，如果想访问该属性，除了继承的子类外，可在A类中声明B类为A的友元：（如13行）
friend class Others；

---

友元类 friend+class名（不是对象）
使得友元类可以使用该类的
当A类中定义B为A的友元类，则类B可以使用A的方法和属性

#include <iostream>
class Lovers
{
public :
    Lovers(std::string theName);

    void kiss(Lovers *lover);
    void ask(Lovers *lover,std::string something);

protected:
    std::string name;

    friend class Others;
};

class Boyfriend : public Lovers
{
public:
    Boyfriend(std::string theName);
};

class Girlfriend : public Lovers
{
public:
    Girlfriend(std::string theName);
};

class Others
{
public:
    Others(std::string theName);
    void kiss(Lovers *lover);
protected:
    std::string name;
};

Lovers::Lovers(std::string theName)
{
    name = theName;
}
void Lovers::kiss(Lovers *lover)
{
    std::cout<< name <<"亲亲我们的家" << lover->name <<std::endl;
}
void Lovers::ask(Lovers *lover,std::string something)
{
    std::cout << "宝贝儿"<<lover->name << "帮我" <<something <<std::endl;
}

Boyfriend::Boyfriend(std::string theName):Lovers(theName)
{
}
Girlfriend::Girlfriend(std::string theName):Lovers(theName)
{
}

Others::Others(std::string theName)
{
    name = theName;
}
void Others::kiss(Lovers *lover)
{
    std::cout <<name <<"亲一下"<<lover->name <<std::endl;
}

int main()
{
    Boyfriend boyfriend("A君");
    Girlfriend girlfriend("B妞");
    Others others("路人甲");
    girlfriend.kiss(&boyfriend);
    girlfriend.ask(&boyfriend,"洗衣服啦\n");
    std::cout<<"\n 当当当当！路人甲上场\n";
    others.kiss(&girlfriend); //通过kiss方法，访问girlfriend的继承基类Lovers的name
}

运行结果：
B妞亲亲我们的家A君
宝贝儿A君帮我洗衣服啦

当当当当！路人甲上场
路人甲亲一下B妞

---

友元函数 friend +函数，声明为A的友元函数
则在该函数内部，可以访问类A的私有成员
重载“<<”与+运算符为非成员函数
Complex.h文件

#ifndef  _COMPLEX_H
#define _COMPLEX_H
#include <iostream>
using namespace std;
class Complex
{
public:
    Complex(){}
    Complex(float a,float b)
    {
        real = a;
        imag = b;
    }
    friend Complex  operator+(const Complex &c,const Complex &d);
    friend ostream & operator<<(ostream & out,Complex &c );
private:
    float real;
    float imag;
};
#endif // _COMPLEX_H

main.cpp

#include "Complex.h"
Complex operator+(const Complex &c, const Complex &d)
{
    return Complex(c.real+d.real,c.imag+d.imag);
}
ostream & operator<<(ostream &out,Complex & x)
{
    out<<"("<<x.real<<","<<x.imag<<")";
    return out;
}
int main()
{
    Complex c1(3,4),c2(2,2),c3(1,1);
    c1=c1+c2;
    cout<<c1;
    return 0;
}