3-9 友元函数、友元类、友元成员函数

最新推荐文章于 2022-09-20 01:36:15 发布

You图碧

最新推荐文章于 2022-09-20 01:36:15 发布

阅读量562

点赞数

分类专栏： c++转载

本文链接：https://blog.csdn.net/qq_41543888/article/details/101083064

版权

c++转载专栏收录该内容

77 篇文章 6 订阅

订阅专栏

3-9 友元函数、友元类、友元成员函数

友元函数：

public、protected、private：

只要让func成为类Man的友元函数，那么func这个函数就可以访问Man的所有成员，private，protected，public

//Man.h
class Man{
private:
    int Age;
    friend void func(const Man &temp_man); //不属于类，不受public、private、protected的影响
};
 
 
//func.h
#ifndef __FUNC__
#def __FUNC__
 
#include "Man.h"
#include <iostream>
 
void func(const Man &temp_man);
 
#endif
 
//------------------------------------------------------------------
//func.cpp
 
#include "func.h"
 
void func(const Man&temp_man){
    cout << "test" << endl;
}

这个函数不属于类，所以不受public、protected、private的影响

总结：友元函数func（）：通过声明为友元函数，它就能访问这个类的所有成员，包括public、protected、private

友元类

类可以把其他的类定义成友元类。如果你是我的友元类，那么你就可以在你的成员函数中访问我的所有成员

class A{
private:
    int data;
};
 
class B{
public:
    void callA(int x, A &a){
        a.data = x;             //报错，无法访问
        cout << a.data << endl;
    }
 
};

我们修改类A，使得类B成为类A的友元类。

 
Class B; //声明
class A{
private:
    int data;
    friend class B; //这就是友元类的声明，虽然此时B没有定义但是系统没有报错，如果报错可以加一个类B声明
};
 
class B{
public:
    void callA(int x, A &a){
        a.data = x;            
        cout << a.data << endl;
    }
 
};

注意：

每个类自己负责自己的友元类和友元函数；

有缘关系不能被继承；

友元关系是单向的，比如上边类B是类A的友元类，但这并不表示类A是类B的友元类；

友元关系没有传递性，比如B是A的友元类，C是B的友元类，这并不代表C是A的友元类。

友元成员函数

写这种友元成员函数（必须是public权限）必须要有代码组织结构，因为这里边有声明和定义这种依赖关系。

//A.h
#include "B.h"
class A{
private:
    int data;
    int name;
    friend void B::callA(int x, A &a); //友元成员函数
};
 
 
//B.h
//class A;       //声明,文件中只有A这个类名字
#include "A.h"   //文件中，使用了A类中的，成员函数，或变量
class B{
public:
    void callA(int x, A &a){
        a.data = x;
    }
    
};
 
//file.cpp
 
#include "A.h"
#include "B.h"
 
int main(){
    A a;
    B b;
    b.callA(1, a);
}

优点：允许在特定情况下，某些非成员函数访问类的protected，private成员，从而提出友元这个概念；使访问protected与private成员更灵活。

缺点：破坏了类的封装性，降低了类的可靠性和维护性。

C++：友元（非成员友元函数、成员友元函数、友元类）

友元函数 ：既可以是不属于任何类的非成员函数，也可以是另一个类的成员函数，统称为友元函数。友元函数不是当前类的成员函数，而是独立于类的外部函数，但它可以访问该类所有的成员，包括私有成员、保护成员和公有成员。在类中声明友元函数时，需在其函数名前加上关键字friend，此声明可以放在公有部分、也可以放在保护和私有部分。友元函数可以定义在类部，也可以定义在类的外部。

3.8.1 将非成员函数声明为友元函数

//1、将非成员函数声明为友元函数 
// 例3.33 友元函数的使用
#include<iostream>
using namespace std;
class Gril{
  public:
     Gril(char* n,int a)
     {
       name = new char[strlen(n)+1];
       strcpy(name,n);
       age = a;
     }
     ~Gril()
     {
       delete []name;
     }
     friend void display(Gril &);//声明友元函数    //friend void display(Gril );
  private:
     char* name;
     int age;     
}; 
void display(Gril &x) //形参是对象的引用           //void display(Gril x) //形参是对象 
{
     cout<<"女孩的姓名是:"<<x.name<<","<<"年龄:"<<x.age<<endl;
}
int main()
{
  Gril g("小丽",20);
  display(g);    //调用友元函数，实参是对象的引用 
  
  return 0; 
}

/*
 说明：1、友元函数虽然可以访问类对象的私有成员，但它毕竟不是成员函数，因此，在类的
 外部定义友元函数时，不必像成员函数那样，在函数名前加 "类名::"
       2、因为友元函数不是类的成员，所以它不能直接访问对象的数据成员，也不能通过this
 指针访问对象的数据成员，它必须通过作为入口参数传递进来的对象名(或对象指针、对象引用)
 来访问引用对象的数据成员。
       3、由于函数display是Gril类的友元函数，所以display函数可以访问Gril中私有数据成员
name、age。但是，在它们之前必须加上 "对象名."        
*/

例1：非成员友元函数

/*
需求：例如有两个类Gril和Boy，现要求打印所有的男生和女生的名字和年龄，我们只需一个
独立的函数print就能完成，但它必须同时定义为这两个类的友元函数。 
*/
//例如3.34   一个函数定义同时定义为两个类的友元函数
#include<iostream>
using namespace std;
class Boy;      //对Boy类的提前引用声明 
class Gril{
  public:
     Gril(char N[],int A)
     {
       strcpy(name,N);
       age = A;
     }
     friend void print(Gril &x)   //声明print函数是Gril类的友元函数 
     {
       cout<<"女孩的姓名是:"<<x.name<<"  "<<"年龄:"<<x.age<<endl;
     }
  private:
     char name[20];
     int age;   
}; 
class Boy{     //声明Boy类 
  public:
     Boy(char N[],int A)
     {
       strcpy(name,N);
       age = A;
     }
     friend void print(Boy &y)    //声明print函数是Boy类的友元函数
     {
       cout<<"男孩的姓名是:"<<y.name<<"  "<<"年龄:"<<y.age<<endl;
     }
  private:
     char name[20];
     int age;   
}; 
int main()
{
  Gril g1("王萌",12);   //定义Gril类对象g1 
  Gril g2("李芳",14);   //定义Gril类对象g2
  Gril g3("张丽",18);   //定义Gril类对象g3
  
  Boy  b1("张三",11);   //定义Boy类对象b1
  Boy  b2("李四",19);   //定义Boy类对象b2
  Boy  b3("王武",13);   //定义Boy类对象b3
  
  print(g1); //调用友元函数，实参是Gril对象g1 
  print(g2); //调用友元函数，实参是Gril对象g2
  print(g3); //调用友元函数，实参是Gril对象g3
  
  print(b1); //调用友元函数，实参是Boy对象b1
  print(b2); //调用友元函数，实参是Boy对象b2
  print(b3); //调用友元函数，实参是Boy对象b3
  
  return 0;
}

例2：非成员友元函数

#include<iostream>
using namespace std;
class Boy;      //对Boy类的提前引用声明 
class Gril{
  public:
     Gril(char N[],int A)
     {
       strcpy(name,N);
       age = A;
     }
     friend void print(Gril &,Boy &);   //声明print函数是Gril类的友元函数 
  private:
     char name[20];
     int age;   
}; 
class Boy{     //声明Boy类 
  public:
     Boy(char N[],int A)
     {
       strcpy(name,N);
       age = A;
     }
     friend void print(Gril &,Boy &);    //声明print函数是Boy类的友元函数
  private:
     char name[20];
     int age;   
}; 
void print(Gril &x,Boy &y)               //定义print有元函数 
{
     cout<<"女孩的姓名是:"<<x.name<<"  "<<"年龄:"<<x.age<<endl;
     cout<<"男孩的姓名是:"<<y.name<<"  "<<"年龄:"<<y.age<<endl;
}
int main()
{
  Gril g1("王萌",12);   //定义Gril类对象g1 
  Gril g2("李芳",14);   //定义Gril类对象g2
  Gril g3("张丽",18);   //定义Gril类对象g3
  
  Boy  b1("张三",11);   //定义Boy类对象b1
  Boy  b2("李四",19);   //定义Boy类对象b2
  Boy  b3("王武",13);   //定义Boy类对象b3
  
  print(g1,b1); //调用友元函数，实参是Gril对象g1,Boy对象b1
  print(g2,b2); //调用友元函数，实参是Gril对象g2,Boy对象b2
  print(g3,b3); //调用友元函数，实参是Gril对象g3,Boy对象b3
  
  return 0;
}

3.8.2将成员函数声明为友元函数
除了一般的非成员函数可以作为某个类的友元外，一个类的成员函数也可以作为另一个类的友元，它是友元函数中的一种，成为友元成员函数。友元成员函数不仅可以访问自己所在类对象中的私有成员和公有成员，还可以访问friend声明语句所在类对象中的所有成员。

例3.35 一个类的成员函数作为另一个类的友元函数

#include<iostream>
#include<string>
using namespace std;
class Gril;  //对类Gril提前引用声明
class Boy{
  public:
    Boy(char* n,int a)
    {
      name = new char[strlen(n)+1];
      strcpy(name,n);
      age = a;
    }
    void disp(Gril );  //声明函数dis为类Boy为成员函数 
    ~Boy()
    {
      delete []name;
    }
    private:
      char* name;
      int age;
};
class Gril{
   public:
     Gril(char* n,int a)
     {
       name = new char[strlen(n)+1];
       strcpy(name,n);
       age = a;
     }
     friend void Boy::disp(Gril );  //声明类Boy成员函数dis为类Gril的友元函数 
    ~Gril()
    {
      delete []name;
    }
    private:
      char* name;
      int age;
}; 
void Boy::disp(Gril x)                //定义类Boy的成员函数disp，同时也为类Gril的友元函数， 
{                                      //形参为Gril类对象 
   cout<<"男孩的姓名："<<name<<endl;  //函数disp作为Boy类的成员函数 ，可以访问Boy类对象的私有成员 
   cout<<"男孩的年龄："<<age<<endl;   //注释同上 
   cout<<"女孩的姓名："<<x.name<<endl;//函数disp作为Gril类的友元函数,可以访问Gril类对象的私有成员
   cout<<"女孩的年龄："<<x.age<<endl; //注释同上
}
int main()
{
  Boy b("陈大林",11);
  Gril g("张晓好",12);
  b.disp(g);//调用Boy类的对象b的成员函数和Gril类的友元函数disp，实参是Gril类的对象g 
        //因为函数disp是Boy类的成员函数，所以无需通过传递对象，可以直接访问自己的私有数据成员 
  return 0;
}

3.8.3 友元类

不仅函数可以作为一个类的友元，一个类也可以作为另一个类的友元，称为友元类。友元类
的说明方法是在另一个类声明中加入语句。
friend class 类名；

此类名是友元类的类名。这条语句可以放在公有部分，也可以放在私有部分。例如，

class Y{
...
};
class X{
...
friend class Y; //声明类Y是类X的友元类
...
};

当类Y被说明类X的友元时，类Y的所有成员函数都成为类X的友元函数，这就意味着作为
友元类Y中的所有成员函数都可以访问类X中的所有成员(包括私有成员)。

下面的例子中，声明了两个类Boy和Gril，类Boy声明为类Gril的友元，因此类Boy的成员
函数都能成为类Gril的友元函数，它们都可以访问类Gril的私有成员。

例 3.36 友元类的应用

#include<iostream>
#include<string>
using namespace std;
class Gril;           //对友元类的提前引用声明 
class Boy{
   public:
     Boy(char* n,int a)
     {
       name=new char[strlen(n)+1];
       strcpy(name,n);
       age = a;
     } 
     ~Boy()
     {
       delete []name;
     }
     void display1(Gril &);   //声明函数display1为类Boy的成员函数 
     void display2(Gril &);   //声明函数display2为类Boy的成员函数
   private:
     char* name;
     int age;  
};
class Gril{
   public:
     Gril(char* n,int a)
     {
       name=new char[strlen(n)+1];
       strcpy(name,n);
       age = a;
     } 
   ~Gril()
   {
     delete []name;
   }     
   
   friend class Boy;    //声明Boy为类Gril的友元类，则类Boy中的所有成员函数为Gril类的友元成员函数          
  
   private:
     char* name;
     int age;   
}; 
void Boy::display1(Gril &x)
{
  cout<<"男孩的姓名是:"<<name<<endl;
  cout<<"女孩的姓名是:"<<x.name<<endl;
} 

void Boy::display2(Gril &x)
{
  cout<<"男孩的年龄是:"<<age<<endl;
  cout<<"女孩的年龄是:"<<x.age<<endl;
}
int main()
{
  Boy b("陈大林",11);
  Gril g("张晓好",12);
  
  b.display1(g);
  b.display2(g);
  
  return 0;
}

注意：声明一个类A为另一个类B的友元类（则类A的所有成员函数都是类B的友元函数，友元类A的所有成员函数既可以访问自己本类的所有成员，也可以访问类B的所有成员）

#include<iostream>
#include<string>
using namespace std;
class Gril;           //对友元类的提前引用声明 
class Boy{
   public:
     Boy(char* n,int a)
     {
       name=new char[strlen(n)+1];
       strcpy(name,n);
       age = a;
     } 
     ~Boy()
     {
       delete []name;
     }
     void display(Gril &);   //声明函数display为类Boy的成员函数 
   private:
     char* name;
     int age;  
};
class Gril{
   public:
     Gril(char* n,int a)
     {
       name=new char[strlen(n)+1];
       strcpy(name,n);
       age = a;
     } 
   ~Gril()
   {
     delete []name;
   }     
   
   friend class Boy;    //声明Boy为类Gril的友元类，则类Boy中的所有成员函数为Gril类的友元成员函数          
  
   private:
     char* name;
     int age;   
}; 
void Boy::display(Gril &x)
{
  cout<<"男孩的姓名是:"<<name<<endl;
  cout<<"男孩的年龄是:"<<age<<endl;
  cout<<"女孩的姓名是:"<<x.name<<endl;
  cout<<"女孩的年龄是:"<<x.age<<endl;
} 
int main()
{
  Boy b("陈大林",11);
  Gril g("张晓好",12);
  
  b.display(g);

  return 0;
} 

/*
 说明：友元关系是单向的，不具有交换性。若声明了类X是类Y的友元类(即在类Y定义中声明X为friend类)，
 不等于类Y一定是X的友元，这就要看在类X中是否有相应的声明。
 
   友元关系也不具有传递性，若类X是类Y的友元，类Y是类Z的友元，不一定类X是类Z的友元。如果想让类X
   是类Z的友元类，应在类Z中作出声明。 
*/

You图碧

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
3-9 友元函数、友元类、友元成员函数

转自：https://www.cnblogs.com/XYQ-208910/p/4912261.html友元函数：既可以是不属于任何类的非成员函数，也可以是另一个类的成员函数，统称为友元函数。友元函数不是当前类的成员函数，而是独立于类的外部函数，但它可以访问该类所有的成员，包括私有成员、保护成员和公有成员。在类中声明友元函数时，需在其函数名前加上关键字friend，此声明可以放在公有部分...
复制链接

扫一扫