C++中的friend函数详细解析

为什么要使用友元函数

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

实际上具体大概有下面两种情况需要使用友元函数:(1)运算符重载的某些场合需要使用友元。(2)两个类要共享数据的时候。

使用友元函数的优缺点

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

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

C++中的友元机制允许类的非公有成员被一个类或者函数访问,友元按类型分为三种:普通非类成员函数作为友元,类的成员函数作为友元,类作为友元。友元包括友元的声明以及友元的定义。友元的声明默认为了extern,就是说友元类或者友元函数的作用域已经扩展到了包含该类定义的作用域,所以即便我们在类的内部定义友元函数也是没有关系的。

友元可以是一个函数,该函数被称为友元函数;友元也可以是一个类,该类被称为友元类。友元函数的特点是能够访问类中的私有成员的非成员函数。友元函数从语法上看,它与普通函数一样,即在定义上和调用上与普通函数一样。

友元函数的实现可以在类外定义,但必须在类内部声明

友元函数是可以直接访问类的私有成员的非成员函数。它是定义在类外的普通函数,它不属于任何类,

但需要在类的定义中加以声明,声明时只需在友元的名称前加上关键字friend。

我们已知道类具有封装和信息隐藏的特性。只有类的成员函数才能访问类的私有成员,程序中的其他函数是无法访问私有成员的。非成员函数可以访问类中的公有成员,但是如果将数据成员都定义为公有的,这又破坏了隐藏的特性。另外,应该看到在某些情况下,特别是在对某些成员函数多次调用时,由于参数传递,类型检查和安全性检查等都需要时间开销,而影响程序的运行效率。

为了解决上述问题,提出一种使用友元的方案。友元是一种定义在类外部的普通函数,但它需要在类体内进行说明,为了与该类的成员函数加以区别,在说明时前面加以关键字friend。友元不是成员函数,但是它可以访问类中的私有成员。友元的作用在于提高程序的运行效率(即减少了类型检查和安全性检查等都需要的时间开销),但是,它破坏了类的封装性和隐藏性,使得非成员函数可以访问类的私有成员。

1.普通的非成员函数友元

#include "cmath"
#include "iostream"
using namespace std;
class Point
{
public:
   Point(double xx,double yy)
   {
     x=xx;
     y=yy;
   }
   void GetXY();
   friend double Distance(Point &a,Point &b);
protected:
private:
   double x,y;
};
void Point::GetXY()
{
   //cout<<"("<<this->x<<","<<this->y<<")"<<endl;
   cout<<"("<<x<<","<<y<<")"<<endl;
}
double Distance(Point &a,Point &b)
{
   double length;
   length=sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));   //它可以引用类中的私有成员
   return length;
}
int main(void)
{
   Point p1(3.0,4.0),p2(6.0,8.0);
   p1.GetXY();  //成员函数的调用方法,通过使用对象来调用
   p2.GetXY();
   double d = Distance(p1,p2);   //友元函数的调用方法,同普通函数的调用一样,不要像成员函数那样调用
   cout<<d<<endl;
   system("pause");
   return 0;
}

说明:在该程序中的Point类中说明了一个友元函数Distance(),它在说明时前边加friend关键字,标识它不是成员函数,而是友元函数。它的定义方法与普通函数定义一样,而不同于成员函数的定义,因为它不需要指出所属的类。但是,它可以引用类中的私有成员,函数体中的a.x,b.x,a.y,b.y都是类的私有成员,它们是通过对象引用的。在调用友元函数时,也是同普通函数的调用一样,不要像成员函数那样调用。本例中,p1.Getxy()和p2.Getxy()这是成员函数的调用,要用对象来表示。而Distance(p1, p2)是友元函数的调用,它直接调用,不需要对象表示,它的参数是对象。(该程序的功能是已知两点坐标,求出两点的距离。)

下面对上面的代码进行输入、输出流的重载:

#include <cmath>
#include <iostream>
using namespace std;
class Point
{
public:
   Point(double xx,double yy)
   {
      x=xx;
      y=yy;
   }
   void GetXY();
   friend double Distance(Point &a,Point &b);
   friend ostream &operator <<(ostream &a,Point &b);
protected:
private:
   double x,y;
};
// friend ostream& operator<<(ostream& o,A& another);
ostream &operator <<(ostream &out,Point &b)  //在类中声明的时候,可以是ostream &a,函数定义的时候也可以是ostream &out
{
   out<<"("<<b.x<<","<<b.y<<")"<<endl;
   return out;
}
void Point::GetXY()
{
   //cout<<"("<<this->x<<","<<this->y<<")"<<endl;
   //cout<<"("<<x<<","<<y<<")"<<endl;
   cout<<*this;
}
double Distance(Point &a,Point &b)
{
   double length;
   length=sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));
   return length;
}
int main(void)
{
   Point p1(3.0,4.0),p2(6.0,8.0);
   p1.GetXY();
   p2.GetXY();
   double d = Distance(p1,p2);
   cout<<d<<endl;
   system("pause");
   return 0; 

}

2.类作为友元

类作为友元需要注意的是友元类和原始类之间的相互依赖关系,如果在友元类中定义的函数使用到了原始类的私有变量,那么就需要在友元类定义的文件中包含原始类定义的头文件。但是在原始类的定义中(包含友元类声明的那个类),就不需要包含友元类的头文件.

另外,不需要在类定义前去声明友元类,因为友元类的声明自身就是一种声明。

//A.h
#pragma once
#include <iostream>
using namespace std;
class A
{
  //friend class B; //如果不写这句话将会出现编译错误
public:
  ~A(void);
  A();
private:
  int m_nItem;
};
//A.cpp
#include "A.h" 

A::A()
{
  m_nItem =3;
} 

A::~A(void)
{
}
//B.h
#pragma once  

class B
{
public:
  B(void);
  ~B(void);
  int func();
};
//B.cpp
#include "StdAfx.h" 

#include "B.h"
#include "A.h" //must include A.h
#include <iostream> 

B::B(void)
{
} 

B::~B(void)
{
} 

int B::func()
{
  cout<<"This is in B"<<endl;
  A a;
  return a.m_nItem;
}

3.类成员函数作为友元函数

这个稍微有点复杂,因为你要类成员函数作为友元,你在声明友元的时候要用类限定符,所以必须先定义包含友元函数的类,但是在定义友元的函数时候,又必须事先定义原始类。通常的做法先定义包含友元函数的类,再定义原始类,这个顺序不能乱。(如果是友元类,则没有这种这种必须)如下面所示:

//A.h
#pragma once
#include "B.h"
class A
{
friend int B::func(A xx);
public:
  A(void):mx(20),my(30){}
  ~A(void){}
private:
  int mx;
  int my;
};
//B.h
#pragma once
class A;
class B
{
public:
  B(void);
  ~B(void);
  int func(A xx);
};
//B.cpp
#include "B.h"
#include "A.h" 

B::B(void)
{
}
B::~B(void)
{
}
int B::func(A xx)
{
  return xx.mx * xx.my;
}
//main.cpp
#include "A.h"
#include "B.h"
#include <iostream>
using namespace std;
void main()
{
  A a;
  B b;
  cout<<b.func(a)<<endl;
  system("pause");
}

4. 友元不具有相互性,只具有单项性

若类B是类A的友元,类A不一定是类B的友元,要看在类中是否有相应的声明。

5. 友元不能被继承

B是A的友元类,C是B的子类,推不出C是A的友元

6. 友元不具有传递性

B是A的友元,C是B的友元,推不出C是A的友元

7. 友元函数的使用技巧

在用C++实现单例模式时,可以利用友元函数实例化对象。然后把类的构造函数和析构函数都设计成私有函数。

class CMySingleton
{
public:
  friend CMySingleton& InstanceMEC(); 

private:
  CMySingleton() {};
  CMySingleton(const CMySingleton &lxSington) {};
  ~CMySingleton(){};
}; 

CMySingleton& InstanceMEC()
{
  //因为函数InstanceMEC()是类ClxSingletonMEC的友元函数,所以可以访问类所有的成员函数.所以不会有编译错误
  static CMySingleton Instance;
  return Instance;
}

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

(0)

相关推荐

  • C++友元(Friend)用法实例简介

    相对于Java而言,友元是C++中特有的一种元素,很多教材上对其介绍的相对较少,因此初学的时候往往不能很快掌握,本文总结了友元的用法和一些注意的地方,供大家参考借鉴.希望能对初学C++的朋友起到一点帮助作用. 操作步骤: 1)在MyFriend类中,将Father类定义成友元 2)写一个Son类继承自Father类 3)在Father类和Son类的构造函数中分别创建MyFriend对象,并定义其内部的三个变量 4)在MyFriend类的构造函数中创建Father对象,并定义其内部的三个变量 结果

  • C++中的friend友元函数详细解析

    友元函数是可以直接访问类的私有成员的非成员函数.它是定义在类外的普通函数,它不属于任何类,但需要在类的定义中加以声明,声明时只需在友元的名称前加上关键字friend. 我们已知道类具有封装和信息隐藏的特性.只有类的成员函数才能访问类的私有成员,程序中的其他函数是无法访问私有成员的.非成员函数可以访问类中的公有成员,但是如果将数据成员都定义为公有的,这又破坏了隐藏的特性.另外,应该看到在某些情况下,特别是在对某些成员函数多次调用时,由于参数传递,类型检查和安全性检查等都需要时间开销,而影响程序的运

  • 剖析C++编程中friend关键字所修饰的友元函数和友元类

    在某些情况下,为不是类成员的函数或单独类中的所有函数授予成员级别的访问权会更方便.仅类实现器可以声明其友元.函数或类不能将其自身声明为任何类的友元.在类声明中,使用 friend 关键字和非成员函数名称或其他类,以允许其访问你的类的专用和受保护成员. 语法 friend class-name; friend function-declarator; 友元声明 如果声明以前未声明的友元函数,则该函数将被导出到封闭非类范围. 友元声明中声明的函数被视为已使用 extern 关键字声明.(有关 ext

  • 概述C++中的 public protected private friend关键字的用法

    一个C++类中的变量如果如下关键字作为修饰符. 1. public: 程序的任何地方都可以访问. 2 protected: 只有类本身及其派生类和其友元函数,友元类可以访问. 3 private: 只有类本身及其友元函数,友元类可以访问. 4 friend: 用于定义友元函数友元类. 在类里声明的一个普通函数,在前面加上friend修饰符,这个函数就可以访问该类的一切成员,包括private成员. 下面在看下c++ public private protected关键字 1.当在类的内部使用这三

  • C++中的friend函数详细解析

    为什么要使用友元函数 在实现类之间数据共享时,减少系统开销,提高效率.如果类A中的函数要访问类B中的成员(例如:智能指针类的实现),那么类A中该函数要是类B的友元函数.具体来说:为了使其他类的成员函数直接访问该类的私有变量.即:允许外面的类或函数去访问类的私有变量和保护变量,从而使两个类共享同一函数. 实际上具体大概有下面两种情况需要使用友元函数:(1)运算符重载的某些场合需要使用友元.(2)两个类要共享数据的时候. 使用友元函数的优缺点 优点:能够提高效率,表达简单.清晰. 缺点:友元函数破环

  • C++中 Sort函数详细解析

    目录 前言 一.sort函数调用的两种方式 二.sort函数使用场景 三.sort函数排序原理 四.sort函数使用案例 1.升序排列 2.降序排列 实现方式1 实现方式2 3.结构体排序(自定义比较函数) 五.自定义comp函数返回true或false作用 前言 sort函数是algorithm库下的一个函数,sort函数是不稳定的,即大小相同的元素在排序后相对顺序可能发生改变,如果某些场景需要保持相同元素间的相对顺序,可使用stable_sort函数,这里不过多介绍. 一.sort函数调用的

  • Python内置函数详细解析

    目录 1.abs 2.all 3.any 4.callable 5.dir 6.id 7.locals 和 globals 8.hash 9.sum 10.getattr.setattr.delattr 前言: Python 自带了很多的内置函数,极大地方便了我们的开发,下面就来挑几个内置函数,看看底层是怎么实现的.内置函数位于 Python/bitlinmodule.c 中. 1.abs abs 的功能是取一个整数的绝对值,或者取一个复数的模. static PyObject * builti

  • 关于java中@Async异步调用详细解析附代码

    目录 前言 1. @Async讲解 2. 用法 2.1 同步调用 2.2 异步调用 3. 自定义线程池 前言 异步调用与同步调用 同步调用:顺序执行,通过调用返回结果再次执行下一个调用 异步调用:通过调用,无需等待返回结果,执行下一个调用 1. @Async讲解 其@Async的注解代码如下: @Target({ElementType.TYPE, ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) @Documented public

  • Es6 Generator函数详细解析

    ECMAScript 6 (简称 ES6 )作为下一代 JavaScript 语言,将 JavaScript 异步编程带入了一个全新的阶段. Generator函数跟普通函数的写法有非常大的区别: 一是,function关键字与函数名之间有一个星号: 二是,函数体内部使用yield语句,定义不同的内部状态(yield在英语里的意思就是"产出"). 本文重点给大家介绍Es6 Generator函数,具体内容如下所示: /* 一.generator函数的定义 1.Generator 函数是

  • java中Optional的使用详细解析

    Optional的使用详解 1.Optional介绍 Optional 类是一个可以为null的容器对象.如果值存在则isPresent()方法会返回true,调用get()方法会返回该对象. Optional 是个容器:它可以保存类型T的值,或者仅仅保存null.Optional提供很多有用的方法,这样我们就不用显式进行空值检测. Optional 类的引入很好的解决空指针异常. 2.构建Optional 构建一个Optional对象:方法有:empty( ).of( ).ofNullable

  • C语言static修饰函数详细解析

    在C语言中,static的字面意思很容易把我们导入歧途,其实它的作用有三条.介绍它的第一条也是最重要的一条:隐藏.当我们同时编译多个文件时,所有未加static前缀的全局变量和函数都具有全局可见性.为理解这句话,我举例来说明.我们要同时编译两个源文件,一个是a.c,另一个是main.c. 下面是a.c的内容 复制代码 代码如下: char a = 'A'; // global variablevoid msg() {    printf("Hello\n"); } 下面是main.c的

  • springMVC中的view视图详细解析

    目录 1.ThymleafView 2.转发视图 3.重定向视图 4.视图控制器view-controller Spring MVC中的视图是view接口,视图的作用是渲染数据,将模型model中的数据展示给用户. springMVC视图的种类很多,默认有转发视图和重定向视图. 当工程引入jstl的依赖,转发视图会自动转换为jstlView,若使用的视图技术为Thymleaf,在springMVC的配置文件中配置了Thymleaf的视图解析器,由此视图解析器解析之后所得到的是ThymleafVi

  • JavaScript自定义日期格式化函数详细解析

    我们对 JavaScript 扩展其中一个较常的做法便是对 Date.prototype 的扩展.因为我们知道,Date 类只提供了若干获取日期元素的方法,如 getDate(),getMinute()--却没有一个转换为特定字符串的格式化方法.故所以,利用这些细微的方法,加以封装,组合我们想要的日期字符串形式.一般来说,该格式化函数可以定义在 Date 对象的原型身上,也可以独立一个方法写出.定义原型方法的操作如 Date.prototype.format = function(date){-

随机推荐