友元类和友元函数

最新推荐文章于 2024-09-04 13:45:30 发布

m一梦千年b

最新推荐文章于 2024-09-04 13:45:30 发布

阅读量697

点赞数

分类专栏： C/C++ 文章标签： c 类 c++ 友元

本文链接：https://blog.csdn.net/u014473211/article/details/23590333

版权

C/C++ 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

友元类和友元函数

《windows环境多线程编程原理与应用》中解释：

　如果将类的封装比喻成一堵墙的话，那么友元机制就像墙上了开了一个门，那些得到允许的类或函数允许通过这个门访问一般的类或者函数无法访问的私有属性和方法。友元机制使类的封装性得到消弱，所以使用时一定要慎重。

　 ■ 友元类的说明

　　　将外界的某个类在本类的定义中用friend关键字说明为友元，那么外界的类就成为本类的“朋友”，那个类就可以访问本类的私有数据了。

　　　class Merchant

{

private :

int m_MyMoney;

int m_MyRoom;

… …

Public:

Friend class Lawyer;

Int getmoney();

… …

};

Class Lawyer

{

Private:

… …

Public:

… …

};

只有你赋予某个类为你的友元时，那个类才有访问你的私有数据的权利。

　 ■ 说明一个函数为一个类的友元函数则该函数可以访问此类的私有数据和方法。定义方法是在类的定义中，在函数名前加上关键字friend.

《挑战30天C/C++》这样解释：

　在说明什么是友元之前，我们先说明一下为什么需要友元与友元的缺点:
通常对于普通函数来说,要访问类的保护成员是不可能的，如果想这么做那么必须把类的成员都生命成为public(共用的)，然而这做带来的问题遍是任何外部函数都可以毫无约束的访问它操作它，c++利用friend修饰符，可以让一些你设定的函数能够对这些保护数据进行操作，避免把类成员全部设置成public，最大限度的保护数据成员的安全。
友元能够使得普通函数直接访问类的保护数据，避免了类成员函数的频繁调用，可以节约处理器开销，提高程序的效率，但所矛盾的是，即使是最大限度大保护，同样也破坏了类的封装特性，这即是友元的缺点，在现在cpu速度越来越快的今天我们并不推荐使用它，但它作为c++一个必要的知识点，一个完整的组成部分，我们还是需要讨论一下的。
在类里声明一个普通函数，在前面加上friend修饰，那么这个函数就成了该类的友元，可以访问该类的一切成员。

1.为什么要使用友元函数

在实现类之间数据共享时，减少系统开销，提高效率。如果类A中的函数要访问类B中的成员（例如：智能指针类的实现），那么类A中该函数要是类B的友元函数。具体来说：为了使其他类的成员函数直接访问该类的私有变量。即：允许外面的类或函数去访问类的私有变量和保护变量，从而使两个类共享同一函数。

实际上具体大概有下面两种情况需要使用友元函数：

（1）运算符重载的某些场合需要使用友元。

（2）两个类要共享数据的时候。

2.使用友元函数的优缺点

优点：能够提高效率，表达简单、清晰。

缺点：友元函数破环了封装机制，尽量不使用成员函数，除非不得已的情况下才使用友元函数。

3.友元函数的参数：

因为友元函数没有this指针，则参数要有三种情况：

①要访问非static成员时，需要对象做参数；

② 要访问static成员或全局变量时，则不需要对象做参数；

③如果做参数的对象是全局对象，则不需要对象做参数；

4.友元函数的位置

因为友元函数是类外的函数，所以它的声明可以放在类的私有段或公有段,且没有区别。

5.友元函数的调用

可以直接调用友元函数，不需要通过对象或指针

6.友元函数的分类

6.1普通函数友元函数

作用及目的：使普通函数能够访问类的友元

其使用语法语法：

声明： friend + 普通函数声明

实现位置：可以在类外或类中

实现代码：与普通函数相同

调用：类似普通函数，直接调用

class INTEGER//定义一个名为INTEGER的类

{

　friend void Print(const INTEGER& obj);//声明友元函数并以对象做参数

};

void Print(const INTEGER& obj）//实现友元函数

{

　　 //函数体

}

void main()

{

　　INTEGER obj;//定义一个对象名为obj

　　Print(obj);//直接调用

}

6.2。类Y的所有成员函数都为类X友元函数—友元类(用的最多)

作用及目的：使用单个声明使Y类的所有函数成为类X的友元，它提供一种类之间合作的一种方式，使类Y的对象可以具有类X和类Y的功能。

其使用语法：

声明位置：公有私有均可，常写为私有(把类看成一个变量)

声明： friend + 类名（不是对象!!!!!）

class girl;声明一个类

class boy//定义一个类名字为boy

{

public://boy公有成员

　 void disp(girl &);//公有成员函数,其函数参数为另一个类girl的对象

};

void boy::disp(girl &x) //函数disp()为类boy的成员函数，也是类girl的友元函数

{

　　cout<<"girl's name is:"<<x.name<<",age:"<<x.age<<endl;//借助友元，在boy的成员函数disp中，借助girl的对象，直接访问girl的私有变量

}

class girl //定义girl类

{

private：//girl类私有成员

　　char *name;

　　int age;

　　friend boy; //声明类boy是类girl的友元,也就是说boy的成员函数可以访问girl的私有数据成员

};

6.3.类Y的一个成员函数为类X的友元函数

作用及目的：使类Y的一个成员函数成为类X的友元，具体而言：在类Y的这个成员函数中，借助参数X，可以直接以X的私有变量

其使用语法：

声明位置：声明在公有中（本身为函数）

声明：friend + 成员函数的声明

调用：先定义Y的对象y---使用y调用自己的成员函数---自己的成员函数中使用了友元机制

2.4.3.3代码：

实现代码和2.4.2.3中的实现及其相似只是设置友元的时候变为friend void boy::disp(girl &);

下面我们来看一段代码，看看我们是如何利用友元来访问类的一切成员的

      #include <iostream>
using namespace std;
class Internet
{
   public:
     Internet(const char *name , const char *address)
     {
      strcpy(Internet::name,name);
      strcpy(Internet::address,address);
     }
     private: 　　　　　　　　　　　　　

char name[20];
char address[20];

friend void ShowN(Internet &obj); //友元函数的声明

};
void ShowN(Internet &obj)

         {
       cout<<obj.name<<endl;       //可访问internet类中的成员
   }
void main()
{
     Internet a("中国软件开发实验室","www.cndev-lab.com");
     ShowN(a);
     cin.get();
}
上面的代码通过友元函数的定义，我们成功的访问到了a对象的保护成员name,友元函数并不能看做是类的成员函数，它只是个被声明为类友元的普通函数，所以在类外部函数的定义部分不能够写成void Internet::ShowN(Internet &obj)，这一点要注意。

一个普通函数可以是多个类的友元函数，对上面的代码我们进行修改，注意观察变化:

#include <iostream>
using namespace std;
class Country;
class Internet
{
  public:
      Iinternet(const char *name , const char *address)
     {
        strcpy(Internet::name,name);
        strcpy(Internet::address,address);
     }

   friend void ShowN(Internet &obj,Country &cn);//注意这里
  public:
      char name[20];
      char address[20];
};
class Country
{
    public:
        Country()
       {
        strcpy(cname,"中国");
       }
  friend void ShowN(Internet &obj,Country &cn);//注意这里
     protected:
        char cname[30];
};

void ShowN(Internet &obj,Country &cn)
{
      cout<<cn.cname<<"|"<<obj.name<<endl;
}
void main()
{
     Internet a("中国软件开发实验室","www.cndev-lab.com");
      Country b;
      ShowN(a,b);
      cin.get();
}

一个类的成员函数函数也可以是另一个类的友元，从而可以使得一个类的成员函数可以操作另一个类的数据成员，我们在下面的代码中增加一类Country，注意观察

#include <iostream>
using namespace std;
class Internet;
class Country
{
    public:
Country()
{
    strcpy(cname,"中国");
}
void Editurl(Internet &temp)               ;//成员函数的声明
protected:
char cname[30];
};
class Internet
{
public:
Internet(char *name,char *address)
{
strcpy(Internet::name,name);
strcpy(Internet::address,address);
}
friend void Country::Editurl(Internet &temp);  //友元函数的声明
protected:
char name[20];
char address[20];
};
void Country::Editurl(Internet &temp)        //成员函数的外部定义
{
strcpy(temp.address,"edu.cndev-lab.com");
cout<<temp.name<<"|"<<temp.address<<endl;
}
void main()
{
Internet a("中国软件开发实验室","www.cndev-lab.com");
Country b;
b.Editurl(a);
cin.get();
}

整个类也可以是另一个类的友元，该友元也可以称做为友类。友类的每个成员函数都可以访问另一个类的所有成员

#include <iostream>
using namespace std;
class Internet;
class Country
{
public:
Country()
{
strcpy(cname,"中国");
}
friend class Internet; //友类的声明
protected:
char cname[30];
};
class Internet
{
public:
Internet(char *name,char *address)
{
strcpy(Internet::name,name);
strcpy(Internet::address,address);
}
void Editcname(Country &temp);
protected:
char name[20];
char address[20];
};
void Internet::Editcname(Country &temp)
{
strcpy(temp.cname,"中华人民共和国");
}
void main()
{
Internet a("中国软件开发实验室","www.cndev-lab.com");
Country b;
a.Editcname(b);
cin.get();
}