朋友类及函数

/* friend.cpp
*
*朋友类的访问
*/
#include <iostream>
#include <string>

using namespace std;

class Pal {
    friend class Buddy;
private:
    string label;
protected:
    void PutLabel(string arg) { label = arg; }
public:
    Pal(string arg):label(arg) { }
};

class Buddy {
private:
    Pal palObject;
public:
    Buddy(string arg):palObject(arg) { }
    void FriendDemo();
};

int main()
{
    Buddy aBuddy("First Message");
    aBuddy.FriendDemo();

    return 0;
}

void Buddy::FriendDemo()
{
    cout << "Reading private Pal::message from Buddy" << endl;
    cout << palObject.label << endl;
    cout << "Calling protected Pal:PutLabel function" << endl;
    palObject.PutLabel("Second Message");
    cout << palObject.label << endl;
    cout << "Writing private Pal::message from Buddy" << endl;
    palObject.label = "Third Message";
    cout << palObject.label << endl;
}

两个类互为朋友，一个类可以实现另一友类的私有，保护成员




/* mutual.cpp
*
*朋友类--两个类之间静态成员的相互访问
*/

#include

using namespace std;

class BClass;

class AClass {
    friend class BClass;
private:
    static int x;
public:
    AClass(int arg) { x = arg; }
    void AFunction();
};

class BClass {
    friend class AClass;
private:
    static int y;
public:
    BClass(int arg) { y = arg; }
    void BFunction();
};

//这里需要声明，否则友类调用时会提示未定义
int AClass::x;
int BClass::y;

int main()
{
    AClass a(123);
    BClass b(456);
    a.AFunction();
    b.BFunction();

    return 0;
}

void AClass::AFunction()
{
    cout << "Inside AClass::AFunction()" << endl;
    cout << "x == " << x << ";y == " << BClass::y << endl;
}

void BClass::BFunction()
{
    cout << "Inside BClass:BFunction()" << endl;
    cout << "x == " << AClass::x << ";y == " << y << endl;
}

朋友类的静态数据调用，实现了两个类的数据共享；值会累计不会一次调用后失效。。




/* friendfn.cpp
* 友元函数
*/
#include
#include

using namespace std;

class Two;

class One {
    friend void Show(One &c1, Two &c2);
private:
    string s1;    // Accessible to one and show()
public:
    One() { s1 = "Testing "; }
};

class Two {
    friend void Show(One &c1, Two &c2);
private:
    string s2;
public:
    Two() { s2 = "one, two, three"; }
};

int main()
{
    One obj1;
    Two obj2;
    Show(obj1, obj2);

    return 0;
}

//友元函数可以访问类的私有，保护成员
void Show(One &obj1, Two &obj2)
{
    cout << obj1.s1 << obj2.s2 << endl;
}

  一个函数为类的朋友，称为友元函数。这里函数Show()为两个类的朋友，可以访问这两个类的保护成员而
不受限制



/* friendmf.cpp
*朋友成员函数
*/
#include
#include

using namespace std;

class One ;

class Two {
private:
    string s2;
public:
    Two() { s2 = "one, two, three"; }
    void Show(One &c1);
};

class One {
    friend void Two::Show(One &c1);
private:
    string s1;
public:
    One() { s1 = "Testing "; }
};

int main()
{
    One obj1;
    Two obj2;
    obj2.Show(obj1);

    return 0;
}

void Two::Show(One &obj1)
{
    cout << obj1.s1 << s2 << endl;
}

一个类的函数是另一个类的朋友，称为朋友成员函数。。产生了和上例相同的输出



  一个类可以声明另一个类或函数为朋友，使朋友能访问声明类的专用成员与保护成员。由于朋友破坏了编写
健全C++程序的规则，因此只在绝对必要时才使用朋友。但朋友可以利用的时候，重要的一个就是重载操作符。。