精华内容
下载资源
问答
  • 友元

    2019-11-24 21:41:14
    (2) 友元关系是单向的,不具有交换性。若类B是类A的友元,类A不一定是类B的友元,要看在类中是否有相应的声明。 (3) 友元关系不具有传递性。若类B是类A的友元,类C是B的友元,类C不一定是类A的友元,同样要看...

    序言

    这章主要是讲解C++中友元,其中友元包括友元函数与友元类。它的主要作用是可以访问类中已隐藏或者封闭的私有或者保护的数据成员或者函数。
    关于友元其特性:

    (1) 友元关系不能被继承。
    (2) 友元关系是单向的,不具有交换性。若类B是类A的友元,类A不一定是类B的友元,要看在类中是否有相应的声明。
    (3) 友元关系不具有传递性。若类B是类A的友元,类C是B的友元,类C不一定是类A的友元,同样要看类中是否有相应的申明

    友元函数

    1. 友元函数是独立于类的外部函数
    #include <QString>
    #include <QDebug>
    
    class Girl
    {
    public:
        Girl(QString name, int age);
        friend void showInfo(Girl&);
    private:
        QString m_name;
        int m_age;
    };
    
    void showInfo(Girl &girl);
    
    #include "girl.h"
    
    Girl::Girl(QString name, int age)
    {
        m_name = name;
        m_age = age;
    }
    
    void showInfo(Girl &girl)
    {
        qDebug() << " name = " << girl.m_name << " age = " << girl.m_age;
    }
    

    结果:
    在这里插入图片描述

    1. 友元函数为某个类中成员函数时
    
    #include <QString>
    #include <QDebug>
    #include "girl.h"
    class Boy
    {
    public:
        Boy(QString name, int age);
        friend void Girl::showInfo(Boy&); //girl中类成员函数作为友元函数
    private:
        QString m_name;
        int m_age;
    };
    
    
    Boy::Boy(QString name, int age)
        :m_age(age)
        ,m_name(name)
    {
    
    }
    
    #include <QString>
    #include <QDebug>
    class Boy;
    class Girl
    {
    public:
        Girl(QString name, int age);
        void showInfo(Boy&);
    private:
        QString m_name;
        int m_age;
    };
    
    
    #include "girl.h"
    #include "boy.h"
    Girl::Girl(QString name, int age)
        :m_age(age)
        ,m_name(name)
    {
    }
    
    void Girl::showInfo(Boy &boy)
    {
        qDebug() << " boy name = " << boy.m_name << " boy age = " << boy.m_age;
        qDebug() << " girl name = " << m_name << " girl age = " << m_age;
    }
    
    
     Girl girl("zhangsan", 12);
        Boy boy("lisi", 14);
        girl.showInfo(boy);
    

    结果图:
    在这里插入图片描述
    3. 把某个类作为另一个类的友元类

    #include <QString>
    #include <QDebug>
    class Boy;
    class Girl
    {
    public:
        Girl(QString name, int age);
        friend Boy;
    private:
        QString m_name;
        int m_age;
    };
    
    #include <QString>
    #include <QDebug>
    class Girl;
    class Boy
    {
    public:
        Boy(QString name, int age);
        void showInfo(Girl&);
    private:
        QString m_name;
        int m_age;
    };
    
    #include "boy.h"
    #include "girl.h"
    Boy::Boy(QString name, int age)
        :m_age(age)
        ,m_name(name)
    {
    
    }
    
    void Boy::showInfo(Girl & girl)
    {
        qDebug() << " girl name = " << girl.m_name << " girl age = " << girl.m_age;
    }
    
    
    
    Girl girl("zhangsan", 12);
        Boy boy("lisi", 14);
        boy.showInfo(girl);
    

    结果:
    在这里插入图片描述

    总结

    引入友元提高了程序的编程效率的同时在某些情况下他也破坏了类的封装性与隐蔽性。

    展开全文
  • 友元

    2019-08-19 15:52:14
    (2) 友元关系是单向的,不具有交换性。若类B是类A的友元,类A不一定是类B的友元,要看在类中是否有相应的声明。 (3) 友元关系不具有传递性。若类B是类A的友元,类C是B的友元,类C不一定是类A的友元,同样要看类中...

     使用友元类时注意:
                 (1) 友元关系不能被继承。 
                 (2) 友元关系是单向的,不具有交换性。若类B是类A的友元,类A不一定是类B的友元,要看在类中是否有相应的声明。
                 (3) 友元关系不具有传递性。若类B是类A的友元,类C是B的友元,类C不一定是类A的友元,同样要看类中是否有相应的申明
     

    #include<iostream>
    using namespace std;
    class A
    {
    public:
        A(int x):x(x){};
    
        friend class B;
    
    private:
        int x;
    
    };
    class B
    {
    public:
        B(A a):a(a){};
    
    void display()
    {
        cout<<a.x<<endl;
    }
    
    private:
        A a;
    
    };
    int main()
    {
        A a(3);
        B b(a);
        b.display();
        return 0;
    }

     

    展开全文
  • C++: 友元函数和友元类详解

    千次阅读 2016-07-17 22:40:42
    (2) 友元关系是单向的,不具有交换性。若类B是类A的友元,类A不一定是类B的友元,要看在类中是否有相应的声明。 (3) 友元关系不具有传递性。若类B是类A的友元,类C是B的友元,类C不一定是类A的友元,同样要看类中...

    转载自:http://blog.chinaunix.net/uid-790245-id-2037327.html  (谢谢作者总结和分享)

    问题的提出

      我们已知道类具备封装和信息隐 藏的特性。只有类的成员函数才能访问类的私有成员,程式中的其他函数是无法访问私有成员的。非成员函数能够访问类中的公有成员,但是假如将数据成员都定义 为公有的,这又破坏了隐藏的特性。另外,应该看到在某些情况下,特别是在对某些成员函数多次调用时,由于参数传递,类型检查和安全性检查等都需要时间开 销,而影响程式的运行效率。
      为了解决上述问题,提出一种使用友元的方案。友元是一种定义在类外部的普通函数,但他需要在类体内进行说 明,为了和该类的成员函数加以区别,在说明时前面加以关键字friend。友元不是成员函数,但是他能够访问类中的私有成员。友元的作用在于提高程式的运 行效率,但是,他破坏了类的封装性和隐藏性,使得非成员函数能够访问类的私有成员。
      友元能够是个函数,该函数被称为友元函数;友元也能够是个类,该类被称为友元类。

      友元函数

      友元函数的特点是能够访问类中的私有成员的非成员函数。友元函数从语法上看,他和普通函数相同,即在定义上和调用上和普通函数相同。下面举一例子说明友元函数的应用。
     
     #include 
      #include 
    
      class Point
      {
      public:
        Point(double xx, double yy) { x=xx; y=yy; }
        void Getxy();
        friend double Distance(Point &a, Point &b);
      private:
        double x, y;
      };
    
      void Point::Getxy()
      {
      cout<<"("<<<","<<<")"<< FONT>
      }
    
      double Distance(Point &a, Point &b)
      {
      double dx = a.x - b.x;
      double dy = a.y - b.y;
      return sqrt(dx*dx+dy*dy);
      }
    
      void main()
      {
      Point p1(3.0, 4.0), p2(6.0, 8.0);
      p1.Getxy();
      p2.Getxy();
      double d = Distance(p1, p2);
      cout<<"Distance is"<<< FONT>
      }
    

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

      友元类

      友元除了前面讲过的函数以外,友元还能够是类,即一个类能够作另一个类的友元。当一个类作为另一个类的友元时,这就意味着这个类的任何成员函数都是另一个类的友元函数。

    采用类的机制后实现了数据的隐藏与封装,类的数据成员一般定义为私有成员,成员函数一般定义为公有的,依此提供类与外界间的通信接口。但是,有时需要定义一 些函数,这些函数不是类的一部分,但又需要频繁地访问类的数据成员,这时可以将这些函数定义为该函数的友元函数。除了友元函数外,还有友元类,两者统称为 友元。友元的作用是提高了程序的运行效率(即减少了类型检查和安全性检查等都需要时间开销),但它破坏了类的封装性和隐藏性,使得非成员函数可以访问类的 私有成员。
    友元函数  
          友元函数是可以直接访问类的私有成员的非成员函数。它是定义在类外的普通函数,它不属于任何类,但需要在类的定义中加以声明,声明时只需在友元的名称前加上关键字friend,其格式如下:
          friend  类型 函数名(形式参数);

          友元函数的声明可以放在类的私有部分,也可以放在公有部分,它们是没有区别的,都说明是该类的一个友元函数。
          一个函数可以是多个类的友元函数,只需要在各个类中分别声明。
          友元函数的调用与一般函数的调用方式和原理一致。

    友元类  
          友元类的所有成员函数都是另一个类的友元函数,都可以访问另一个类中的隐藏信息(包括私有成员和保护成员)。       
          当希望一个类可以存取另一个类的私有成员时,可以将该类声明为另一类的友元类。定义友元类的语句格式如下:
          friend class 类名;
          其中:friend和class是关键字,类名必须是程序中的一个已定义过的类。

          例如,以下语句说明类B是类A的友元类:
          class A
          {
                 …
          public:
                 friend class B;
                 …
          };
          经过以上说明后,类B的所有成员函数都是类A的友元函数,能存取类A的私有成员和保护成员。

          使用友元类时注意:
                (1) 
    友元关系不能被继承。 
                (2) 友元关系是单向的,不具有交换性。若类B是类A的友元,类A不一定是类B的友元,要看在类中是否有相应的声明。
                (3) 友元关系不具有传递性。若类B是类A的友元,类C是B的友元,类C不一定是类A的友元,同样要看类中是否有相应的申明

    注意事项:

    1.友元可以访问类的私有成员。

    2.只能出现在类定义内部,友元声明可以在类中的任何地方,一般放在类定义的开始或结尾。

    3.友元可以是普通的非成员函数,或前面定义的其他类的成员函数,或整个类。

    4.类必须将重载函数集中每一个希望设为友元的函数都声明为友元。

    5.友元关系不能继承,基类的友元对派生类的成员没有特殊的访问权限。如果基类被授予友元关系,则只有基类具有特殊的访问权限。该基类的派生类不能访问授予友元关系的类。

    展开全文
  • 友元函数

    2011-11-30 19:21:32
    (2)友元关系是单向的,不具有交换性。若类B是类A的友元,类A不一定是类B的友元,要看在类中是否有相应的声明。为了公平起见,两个类应当相互声明对方为友元。(3)友元关系不具有传递性。假设A声明为一个类,B是A...
    关于友元,还需注意以下几点:(1)友元关系不能被继承。(2)友元关系是单向的,不具有交换性。若类B是类A的友元,类A不一定是类B的友元,要看在类中是否有相应的声明。为了公平起见,两个类应当相互声明对方为友元。(3)友元关系不具有传递性。假设A声明为一个类,B是A的友元类,C是B的友元函数,则在类B中可以访问类A中的私有成员,通过C函数可以访问类B中的私有成员,但是通过C的函数并不能访问类A中的私有成员。
    
    展开全文
  • 5 友元

    2017-07-24 10:23:00
    类A是类B的友元,类C是类A的公有...(2) 友元关系是单向的,不具有交换性。若类B是类A的友元,类A不一定是类B的友元,要看在类中是否有相应的声明。(3) 友元关系不具有传递性。若类B是类A的友元,类C是B的友元,类C...
  • 关于友元继承

    2019-06-22 15:38:42
    关于友元继承 友元能够是个函数,该函数被称为友元函数;友元也能够是个类,该类被称为友元类。 在C++中,自定义函数可以充当友元,友元只是能访问指定类的私有和保护成员的自定义函数,不是被...(3) 友元关系不具有...
  • C++友元简单说明

    2019-09-23 17:06:07
    关于友元通常情况下访问一个类中的私有成员必须调用其类的成员函数进行访问但如果在类中声明一个友元函数,类外定义时...注意:(1)友元关系不能被继承(2)友元关系是单向的不具有交换性(3)同样友元关系不具有传...
  • C++ 中的友元(friend)

    2017-07-30 21:07:00
    友元关系是单向的,不具有交换性友元关系不具有传递性。 类内声明的 friend 变量(或者函数)在访问该类的成员时,不受 private 的约束。 1. 实现单例 class Printer { public: friend Printer&am...
  • C++:49---继承中的友元

    2020-12-23 07:50:59
    一、友元在继承中的关系我们在友元的文章中介绍过,友元关系不能继承。(1)友元关系不存在传递性,即每个类负责控制自己的友元类或者友元函数;(2)友元关系是单向的,不具有交换性。若类B是类A...
  • 友元类的相关知识

    千次阅读 2012-08-09 17:58:41
     3、友元关系是单向的,不具有交换性。若类B是类A的友元,类A不一定是类B的友元,要看在类中是否有相应的声明。  4、友元关系不具有传递性。若类B是类A的友元,类C是B的友元,类C不一定是类A的友元,同样要看...
  • 友元函数 自考教材中的简单介绍 (2008版教材P109)友元函数可以存取私有成员、公有成员和保护成员。...这种友元关系不具有交换性,即当说明类A是类B的友元时,类B不一定是类A的友元。 目录 友元函数 1.友...
  • 使用友元类注意事项

    2011-07-06 16:45:19
    使用友元类时应注意: (1) 友元关系不能被继承。 (2) 友元关系是单向的,不具有交换性。若类B是类A的友元,类A不一定是类B的友元,要看在类中是否有相应的声明。 (3) 友元关系不具有传递
  • C++--友元

    2019-10-03 03:08:48
    2014-07-0414:02:53 C++复习时碰到的友元类,由于上课时老师没有讲,所以在这里做一个补充。 ... (1) 友元关系不能被继承。...(2) 友元关系是单向的,不具有交换性。若类B是类A的友元,类A不一...
  • 1.友元关系是单向的,不具有交换性。 例如:一个类A中声明了类B是A的友元,B就可以访问A的私有成员,而A不可以访问B的私有成员。 2.友元关系不能传递。 单向都不可以都不用说传递了,友元类只看声明。 友元类的声明...
  • 类A是类B的友元,类C是类A的公有派生类,忽略特殊情况则下列说法正确的是() 类B是类A的友元 ...友元关系是单向的,不具有交换性。若类B是类A的友元,类A不一定是类B的友元,要看在类中是否有相应的声明。 (3
  • friend访问类型(友元类)

    千次阅读 2013-11-10 21:36:28
    在一个类中不仅仅只能声明另外一个函数为本类的友元函数,还可以声明一个类是本类的友元类。 形式: class C{  //....  friend class B;...这意味着,B类中的所有成员函数都...友元关系是单向的,不具有交换性。若类
  • 一、友元 友元分为:友元函数和友元类。 在上一篇中,介绍到了C++突破封装的方式之一,友元函数,这...友元关系是单向的,不具有交换性。 即:若有两个类A和B,在A类中声明B类为其友元类,那么就可以在B类中直接访...
  • 为了能在友元函数中访问并设置类的私有数据成员,一个类的友元函数一般将该类的引用作为函数参数7友元关系是单方向的,不具有交换性和传递性,使用友元虽然可以简化编程,...
  • 刚开始想到了private的构造函数, 后来... (2) 友元关系是单向的,不具有交换性。若类B是类A的友元,类A不一定是类B的友元,要看在类中是否有相应的声明。  (3) 友元关系不具有传递性。若类B是类A的友元,类C是B的
  • public 所有均可访问private 类自己的成员函数...友元关系是单向的,不具有交换性。若类B是类A的友元,类A不一定是类B的友元,要看在类中是否有相应的声明。友元关系不具有传递性。若类B是类A的友元,类C是B的友...
  • web前端day3

    2021-01-09 21:41:26
    (2) 友元关系是单向的,不具有交换性。若类B是类A的友元,类A不一定是类B的友元,要看在类中是否有相应的声明。 (3) 友元关系不具有传递性。若类B是类A的友元,类C是B的友元,类C不一定是类A的友元,同样要看类中...
  • 这样,程序模块间的关系更为简单,程序模块的独立、数据的安全就有了良好的保障。通过实现继承与多态,还可以大大提高程序的可重用,使得软件的开发和维护都更为方便。 面向对象方法所强调的基本原则,就是...
  • C++基础知识

    2018-03-06 10:31:59
    友元关系不能被继承,不具有交换性,不具有传递性 友元提高了程序的运行效率,但是破坏了类的封装性和隐藏性 归纳起来:友元函数是一种能够访问类中的私有成员的非成员函数 一个类的友元函数能够访问类的所有成员...
  • C++基础整理

    2016-10-18 21:58:51
    一、友元 a.友元函数:允许外面的类或函数去访问类的私有变量和保护变量 b.友元类 class A { ...2)友元关系是单向的,不具有交换性。若类B是类A的友元,类A不一定是类B的友元,要看在类中是否有相
  • C++类与对象(二)

    2020-10-27 17:38:22
    友元 功能: 突破封装 缺点: 会增加耦合度,破坏封装 友元分为友元函数和友元类 友元函数 1. 可以直接访问类的私有成员 ...1. 友元关系是单向的,不具有交换性 2. 友元关系不能传递 内部类 概念: 如
  • 18.3.1 swap() 交换两个字符串的内容 389 18.3.2 将string型字符串转为char型字符串 390 18.3.3 char型字符串与函数 391 18.3.4 函数如何返回字符串 392 18.4 结构体 394 18.4.1 结构体的赋值 397 18.4.2 ...

空空如也

空空如也

1 2
收藏数 38
精华内容 15
热门标签
关键字:

友元关系不具有交换性