【C++】友元

目录

友元简介

全局函数做友元

成员函数做友元

类做友元

---

友元简介

友元的作用：

外界不能直接调用私有成员函数，可以设置一个接口获得一个成员函数，但是如果成员多了要调用就很麻烦，友元可以解决这个问题。

友元：friend

友元将某些特殊需求的函数/类作为某个类的朋友，使这些特殊函数/类可以访问那个类的prviate/proteced成员。

---

友元的三种类型：

1. 全局函数作为类的友元
   1. 可以在此函数中通过对象访问当前类的私有成员
2. 成员函数作为另外一个类的友元
   1. 可以在此函数中通过对象访问另外一个类的私有数据成员
3. 类作为另外一个类的友元类，
   1. 此类中的所有成员函数都可以通过另外一个类的对象访问私有数据成员
   2. 友元的特性：不传递，不对称，不继承

---

全局函数做友元

• 做友元的函数需要在类内声明（前面加friend关键字），但是它不属于成员函数,不能在类内定义。
• 友元不区分访问权限，可以放在类中的任何地方（公有私有保护）。

class A
{
public:
    A(int i=0):m_i(i){}
    friend void Sum(A& a, A& b);//声明友元
private:
    int m_i;
};
//友元函数，从外界访问私有
void Sum(A& a,A& b)
{
    cout << a.m_i + b.m_i << endl;//外界不能直接调用私有成员
}
int main()
{
    A a(4);
    A b(1);
    Sum(a, b);//5

    return 0;
}

        如果这个全局函数作为多个类的友元，则每个类里面都要声明这个友元。

下面的代码Sum用了两个类的私有成员，所以两个类里面分别声明了Sum（6，14行）。

注意：两个类对象作为参数传入，在类中声明这个友元函数的前面，两个类必须都要声明过（第1行），否则定义中（20行）报错，显示无法访问第一个类（A类）的私有成员。

class B;//前向引用声明
class A
{
public:
    A(int i = 0) :m_i(i) {}
    friend void Sum(A& a, B& b);//这里要用B，所以前面有个声明
private:
    int m_i;
};
class B
{
public:
    B(int j = 0) :m_j(j) {}
    friend void Sum(A& a, B& b);//这里也要声明Sum
private:
    int m_j;
};
void Sum(A& a, B& b)
{
    cout << a.m_i + b.m_j << endl;
}
int main()
{
    A a(4);
    B b(1);
    Sum(a, b);//5

    return 0;
}

---

成员函数做友元

friend 成员函数声明;

成员函数一般都是类内声明，类外定义。这在成员函数做友元时也是必要的，成员函数的定义不能再类内写因为先声明被访问的类（一定要注意顺序），但它还没有定义，没有可以使用的成员。

class A;//先声明被访问的类
class B
{
public:
    B(int j = 0) :m_j(j) {}
    void Sum(A& a);//可以声明，不能定义，因为上面A没有定义，只有声明
private:
    int m_j;
};
//定义被访问的类
class A
{
public:
    A(int i = 0) :m_i(i) {}
    friend void B::Sum(A& a);//声明成员函数为友元
private:
    int m_i;
};
//定义成员函数
void B::Sum(A& a)//A定义完了再定义这个友元
{
    cout << a.m_i + m_j << endl;
}

int main()
{
    A a(4);
    B b(1);
    b.Sum(a);//5

    return 0;
}

更不能先定义被访问的类，如下：B还没有定义，则作为友元的成员函数甚至还没有定义和声明，无法告诉A哪个是友元。下面这段代码完全错误。

class B;
class A
{
public:
    A(int i = 0) :m_i(i) {}
    friend void B::Sum(A& a);//B类没有定义，不能这样写
private:
    int m_i;
};
class B
{
public:
    B(int j = 0) :m_j(j) {}
    void Sum(A& a)
    {
        cout << a.m_i + m_j << endl;
    }
private:
    int m_j;
};

---

类做友元

friend class 类;

如果类中有很多成员函数需要访问另外一个类的私有保护成员，则把这个类作为另外一个类的友元，减少声明友元成员函数的麻烦。

• 友元是单向的，反对称（如下：B是A的友元，A不是B的友元）

class A;//被访问的类
class B
{
public:
    B(int j = 0) :m_j(j) {}
    void Sum(A& a);//加法
    void Mul(A& a);//乘法
    //friend class A;
private:
    int m_j;
};

class A
{
public:
    A(int i = 0) :m_i(i) {}
/*    错误，友元是单向的
B是A的友元，B能用A的东西，但A不能用B的东西（私有保护）
void fn(B& b)
    {
        cout<<b.m_j<<endl;
    }
*/
    friend class B;
private:
    int m_i;
};

void B::Sum(A& a)
{
    cout << a.m_i + m_j << endl;
}
void B::Mul(A& a)
{
    cout << a.m_i * m_j << endl;
}

int main()
{
    A a(4);
    B b(2);
    b.Sum(a);//6
    b.Mul(a);//8
    return 0;
}

• 友元是不可传递的（A是B的友元，B是C的友元，A不是C的友元）

class A;
class B;
class C;

class B
{
public:
    B(int j = 0) :m_j(j) {}
    void Sum(A& a);
    void Mul(A& a);
    void fb(C& c);
    friend class A;//A是B的友元
private:
    int m_j;
};

class A
{
public:
    A(int i = 0) :m_i(i) {}
    void fa(B& b);
    void faa(C& c);
private:
    int m_i;
};
class C
{
public:
    C(int k = 0) :m_k(k) {}
    friend class B;//B是C的友元
    void fc(A& a);
private:
    int m_k;
};
void A::fa(B& b)//A可以用B的
{
    cout << "fa" << b.m_j << endl;
}
void B::fb(C& c)//B可以用C的
{
    cout << "fb" << c.m_k << endl;
}
/*错误——C不能用A的,A也不能用C的
void C::fc(C& a)
{
    cout << "fc" << a.m_i << endl;
}

void A::faa(C& c)
{
    cout << "faa" << c.m_k << endl;
}
*/