AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

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

2017-10-11 1787
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：

 3.8  友元：友元函数和友元类 

 友元函数 ：既可以是不属于任何类的非成员函数，也可以是另一个类的成员函数，统称为友元函数。友元函数不是当前类的成员函数，而是独立于类的外部函数，但它可以访问该类所有的成员，包括私有成员、保护成员和公有成员。在类中声明友元函数时，需在其函数名前加上关键字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中作出声明。 
*/
复制代码

 

程序猿神奇的手，每时每刻，这双手都在改变着世界的交互方式！
本文转自当天真遇到现实博客园博客，原文链接：http://www.cnblogs.com/XYQ-208910/p/4912261.html ，如需转载请自行联系原作者
文章标签：
C++
程序员
关键词：
C++类
C++友元
C++成员
C++友元函数
C++友元函数类
吞吞吐吐的
目录
相关文章
hahaha无
|
3月前
|
人工智能 机器人 编译器
c++模板初阶----函数模板与类模板
class 类模板名private://类内成员声明class Apublic:A(T val):a(val){}private:T a;return 0;运行结果：注意：类模板中的成员函数若是放在类外定义时，需要加模板参数列表。return 0;
hahaha无
80 0
hahaha无
|
3月前
|
存储 编译器 程序员
c++的类（附含explicit关键字，友元，内部类）
本文介绍了C++中类的核心概念与用法，涵盖封装、继承、多态三大特性。重点讲解了类的定义（`class`与`struct`）、访问限定符（`private`、`public`、`protected`）、类的作用域及成员函数的声明与定义分离。同时深入探讨了类的大小计算、`this`指针、默认成员函数（构造函数、析构函数、拷贝构造、赋值重载）以及运算符重载等内容。 文章还详细分析了`explicit`关键字的作用、静态成员（变量与函数）、友元（友元函数与友元类）的概念及其使用场景，并简要介绍了内部类的特性。
hahaha无
158 0
ephemerals__
|
5月前
|
编译器 C++ 容器
【c++11】c++11新特性（上）（列表初始化、右值引用和移动语义、类的新默认成员函数、lambda表达式）
C++11为C++带来了革命性变化，引入了列表初始化、右值引用、移动语义、类的新默认成员函数和lambda表达式等特性。列表初始化统一了对象初始化方式，initializer_list简化了容器多元素初始化；右值引用和移动语义优化了资源管理，减少拷贝开销；类新增移动构造和移动赋值函数提升性能；lambda表达式提供匿名函数对象，增强代码简洁性和灵活性。这些特性共同推动了现代C++编程的发展，提升了开发效率与程序性能。
ephemerals__
159 12
蓝易云
|
6月前
|
设计模式 安全 C++
【C++进阶】特殊类设计 && 单例模式
通过对特殊类设计和单例模式的深入探讨，我们可以更好地设计和实现复杂的C++程序。特殊类设计提高了代码的安全性和可维护性，而单例模式则确保类的唯一实例性和全局访问性。理解并掌握这些高级设计技巧，对于提升C++编程水平至关重要。
蓝易云
123 16
预备女程序员a
|
6月前
|
编译器 C++
类和对象（中 ）C++
本文详细讲解了C++中的默认成员函数，包括构造函数、析构函数、拷贝构造函数、赋值运算符重载和取地址运算符重载等内容。重点分析了各函数的特点、使用场景及相互关系，如构造函数的主要任务是初始化对象，而非创建空间；析构函数用于清理资源；拷贝构造与赋值运算符的区别在于前者用于创建新对象，后者用于已存在的对象赋值。同时，文章还探讨了运算符重载的规则及其应用场景，并通过实例加深理解。最后强调，若类中存在资源管理，需显式定义拷贝构造和赋值运算符以避免浅拷贝问题。
预备女程序员a
76 1
预备女程序员a
|
6月前
|
存储 编译器 C++
类和对象（上）（C++）
本篇内容主要讲解了C++中类的相关知识，包括类的定义、实例化及this指针的作用。详细说明了类的定义格式、成员函数默认为inline、访问限定符（public、protected、private）的使用规则，以及class与struct的区别。同时分析了类实例化的概念，对象大小的计算规则和内存对齐原则。最后介绍了this指针的工作机制，解释了成员函数如何通过隐含的this指针区分不同对象的数据。这些知识点帮助我们更好地理解C++中类的封装性和对象的实现原理。
预备女程序员a
117 1
预备女程序员a
|
6月前
|
编译器 C++
类和对象（下）C++
本内容主要讲解C++中的初始化列表、类型转换、静态成员、友元、内部类、匿名对象及对象拷贝时的编译器优化。初始化列表用于成员变量定义初始化，尤其对引用、const及无默认构造函数的类类型变量至关重要。类型转换中，`explicit`可禁用隐式转换。静态成员属类而非对象，受访问限定符约束。内部类是独立类，可增强封装性。匿名对象生命周期短，常用于临时场景。编译器会优化对象拷贝以提高效率。最后，鼓励大家通过重复练习提升技能！
预备女程序员a
96 0
平凡程序猿~
|
7月前
|
编译器 C++ 开发者
【C++篇】深度解析类与对象（下）
在上一篇博客中，我们学习了C++的基础类与对象概念，包括类的定义、对象的使用和构造函数的作用。在这一篇，我们将深入探讨C++类的一些重要特性，如构造函数的高级用法、类型转换、static成员、友元、内部类、匿名对象，以及对象拷贝优化等。这些内容可以帮助你更好地理解和应用面向对象编程的核心理念，提升代码的健壮性、灵活性和可维护性。
平凡程序猿~
152 0
羑悻的小杀马特
|
7月前
|
编译器 C语言 C++
类和对象的简述（c++篇）
类和对象的简述（c++篇）
羑悻的小杀马特
166 28
ephemerals__
|
6月前
|
安全 C++
【c++】继承（继承的定义格式、赋值兼容转换、多继承、派生类默认成员函数规则、继承与友元、继承与静态成员）
本文深入探讨了C++中的继承机制，作为面向对象编程（OOP）的核心特性之一。继承通过允许派生类扩展基类的属性和方法，极大促进了代码复用，增强了代码的可维护性和可扩展性。文章详细介绍了继承的基本概念、定义格式、继承方式（public、protected、private）、赋值兼容转换、作用域问题、默认成员函数规则、继承与友元、静态成员、多继承及菱形继承问题，并对比了继承与组合的优缺点。最后总结指出，虽然继承提高了代码灵活性和复用率，但也带来了耦合度高的问题，建议在“has-a”和“is-a”关系同时存在时优先使用组合。
ephemerals__
321 6