C++基礎知識複習與總結（6）---友元friend、友元函數和友元類

為了在類之間進行資料共享時，提高效率，C++引入了友元的概念。友元主要有三個方面的應用：

1. 将普通函數聲明為類的友元函數；
2. 将一個類聲明為其他類的友元類；
3. 将一個類中的成員函數聲明為其他類的友元函數。

下面分别介紹。

1、普通函數聲明為友元函數

将一個普通函數，聲明為某個類的友元函數後(在函數聲明前加上“friend”關鍵字)，該函數就可以通路類中的任何成員。觀察下面的代碼：

#include<iostream>
using namespace std;

class friend_test{
    private:
        int a=;        //非靜态成員變量
        static int b;   //聲明靜态成員變量
    public:
        friend void friend_func(friend_test &f);    //将函數friend_func()函數，聲明為該類的友元函數。由于友元函數沒有this指針
};
int friend_test::b=;   //定義靜态成員變量

//friend_func()函數的實作
void friend_func(friend_test &f)
{
    cout<<"通路基礎類friend_test的私有成員變量：   "<<f.a<<endl;
    cout<<"通路基礎類friend_test的靜态成員變量：   "<<friend_test::b<<endl;
    cout<<"通路基礎類friend_test的靜态成員變量：   "<<f.b<<endl;
}

int main()
{
    friend_test f;    //聲明friend_test類的對象
    friend(f);        //程式運作正常，按預期輸出結果

    return ;
}
           

從上面的程式中可以看出，友元函數通路類的成員變量時，有以下特點：

1. 通路靜态static成員時，可以通過”類名::變量名”和”對象名::變量名”方式通路；
2. 通路非靜态成員時，隻能通過“對象名::變量名”方式通路。

2、友元類

若将類A 聲明為類B的友元類，那麼類A中的所有成員函數都可以通路類B中的所有成員；反之，不成立，即友元不是雙向的。

觀察下面的代碼：

#include<iostream>
using namespace std;

class A;
class B{
    public:
        friend class A;    //聲明類A為類B的友元類
    private:
        int b;
};
class A{
    public:
        void func1(B &BB);  //聲明類A的成員函數
        void func2(B &BB);
};
void A::func1(B &BB)
{
    cout<<"通路類B的成員變量：   "<<BB.b<<endl;
}
void B::func2(B &BB)
{
    cout<<"本函數用不到類B的成員變量"<<endl;
}
int main()
{
    A AA;         //聲明類A的對象
    B BB;         //聲明類B的對象

    A.func1(BB);   //調用類A的成員函數，在成員函數中通路類B的成員變量
    A.func2(BB);
}
           

通過以上代碼，可以發現類A為類B的友類，類A中所有的成員函數都可以通路類B中的所有成員。那麼，此時會帶來一個問題，若類A中的某個函數如上面的“func2()”不需要通路類B的成員變量，隻有函數“func1()”需要通路類B的成員。

由于友元的引入本來就破壞了“封裝”，使得面向對象的顔面有點受損。那麼，可以僅僅設定類A的成員函數func1()為類B的友元函數，進而類B的成員對函數“func2()”就不可見了^-^

上面所述就是将類的成員函數聲明為其他類的友元函數的目的。

3、類的成員函數聲明為其他類的友元函數

正如上面所說，若将類A的某個成員函數”func_A()”聲明為類B的友元函數後，函數”func_A”就可以通路類B中的所有成員。

觀察下面的例子：

#include<iostream>
using namespace std;

class B;
class A{
    public:
        void func_A(B &BB);  //類A的成員函數
        void func();    
};
//類A的成員函數實作
void A::func()
{
    cout<<"我隻是個普通的寶寶~~~"<<endl;
}
class B{
    public:
        friend void A::func_A(B &BB);  //将類A的func_A()成員函數聲明為類B的友元
    private:
        int b=;                      //類B的成員變量
};
//類A中為類B友元的成員函數實作,必須放在類B定義之後
void A::func_A(B &BB)
{
    cout<<"通過類A的成員函數通路類B的成員變量：   "<<BB.b<<endl;
}
int main()
{
    A AA;        //類A的對象
    B BB；       //類B的對象
    A.func();    //通路類A的成員函數
    A.func_A();  //通路類A的成員函數，為類B的友元
}
           

程式運作，符合預期。

通過以上分析，将友元的特點總結如下：

1. 由于友元函數沒有this指針，通路靜态static成員時，可以通過”類名::變量名”和”對象名::變量名”方式通路；
2. 通路非靜态成員時，隻能通過“對象名.變量名”方式通路。
3. 雖能提高效率，但破壞了程式的封裝，盡量減少friend的使用；
4. 在聲明類的成員函數為其他類的友元時，函數實作要放在其他類的定義之後。