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

    2016-04-18 11:54:52
    友元类

    =======================什么是友元类=======================

          当一个类B成为了另外一个类A的“朋友”时,那么类A的私有和保护的数据成员就可以被类B访问。我们就把类B叫做类A的友元。

    =======================友元类能做什么=======================

          友元类可以通过自己的方法来访问把它当做朋友的那个类的所有成员。但是我们应该注意的是,我们把类B设置成了类A的友元类,但是这并不会是类A成为类B的友元。说白了就是:甲愿意把甲的秘密告诉乙,但是乙不见得愿意把乙自己的秘密告诉甲。

    =======================友元类的声明方法和其用法=======================

          声明友元类的方法其实很简单,只要我们在类A的成员列表中写下如下语句:

    friend class B;

      这样一来,类B就被声明成了类A的友元。注意,类B虽然是类A的友元,但是两者之间不存在继承关系。这也就是说,友元类和原来那个类之间并没有什么继承关系,也不存在包含或者是被包含的关系,友元类和我上一篇博文《谈谈:C++类的“包含”机制》中的包含是完全不一样的!

    =======================友元类的一个具体例子=======================

          在这里,我们引用一个我从网上收集到的例子来说明友元类的作用:假设我们要设计一个模拟电视机和遥控器的程序。大家都之道,遥控机类和电视机类是不相包含的,而且,遥控器可以操作电视机,但是电视机无法操作遥控器,这就比较符合友元的特性了。即我们把遥控器类说明成电视机类的友元。下面是这个例子的具体代码:

    #include <iostream>
    using namespace std;
    class TV 
    {
        public:
          friend class Tele;
          TV():on_off(off),volume(20),channel(3),mode(tv){}
        private:    
          enum{on,off};
          enum{tv,av};
          enum{minve,maxve=100};
          enum{mincl,maxcl=60};
          bool on_off;
          int  volume;
          int channel;
          int mode;
    };
    class Tele
    {
        public:
           void OnOFF(TV&t){t.on_off=(t.on_off==t.on)?t.off:t.on;}
           void SetMode(TV&t){t.mode=(t.mode==t.tv)?t.av:t.tv;}
           bool VolumeUp(TV&t);
           bool VolumeDown(TV&t);
           bool ChannelUp(TV&t);
           bool ChannelDown(TV&t);
           void show(TV&t)const;    
    };
    bool Tele::VolumeUp(TV&t)
    {
        if (t.volume<t.maxve)
        {
            t.volume++;
            return true;
        } 
        else
        {
            return false;
        }
    }
    bool Tele::VolumeDown(TV&t)
    {
        if (t.volume>t.minve)
        {
            t.volume--;
            return true;
        } 
        else
        {
            return false;
        }
    }
    bool Tele::ChannelUp(TV&t)
    {
        if (t.channel<t.maxcl)
        {
            t.channel++;
            return true;
        } 
        else
        {
            return false;
        }
    }
    bool Tele::ChannelDown(TV&t)
    {
        if (t.channel>t.mincl)
        {
            t.channel--;
            return true;
        } 
        else
        {
            return false;
        }
    }
    void Tele::show(TV&t)const
    {
        if (t.on_off==t.on)
        {
            cout<<"电视现在"<<(t.on_off==t.on?"开启":"关闭")<<endl;
            cout<<"音量大小为:"<<t.volume<<endl;
            cout<<"信号接收模式为:"<<(t.mode==t.av?"AV":"TV")<<endl;
            cout<<"频道为:"<<t.channel<<endl;
     
        } 
        else
        {
            cout<<"电视现在"<<(t.on_off==t.on?"开启":"关闭")<<endl;
        }
         
    }
    int main()
    {
        Tele t1;
        TV t2;
        t1.show(t2);
        t1.OnOFF(t2);
        t1.show(t2);
        cout<<"调大声音"<<endl;
        t1.VolumeUp(t2);
        cout<<"频道+1"<<endl;
        t1.ChannelUp(t2);
        cout<<"转换模式"<<endl;
        t1.SetMode(t2);
        t1.show(t2);
        return 0;
    }

    转自 http://www.cnblogs.com/uniqueliu/archive/2011/08/02/2125590.html
    展开全文
  • xxx xxxxx 目 录 页 xx C++语言程序设计 xxx xxxxx 目 录 页 C++语言程序设计 绪 论 大连理工大学出版社 地址大连市软件园路80号 E-mail : dutp@ URLhttp://www.dutp,cn 友元函数和友元类 友元函数和友元类 类具有...
  • (2)友元类友元类的成员函数可以访问另一个类的所有 成员,但是友元类的成员函数不是另一个类的成员函数 2.友元函数 友元函数在类作用域外定义,但它需要在类体中进行说明 为了与该类的成员函数加以区别,定义...

    1.友元介绍

    • 友元是一种允许非类成员函数访问类的非公有成员的一种机制。
    • 可以把一个函数指定为类的友元,也可以把整个类指定为另一个类的友元。
      (1)友元函数
      (2)友元类,友元类的成员函数可以访问另一个类的所有
      成员,但是友元类的成员函数不是另一个类的成员函数

    2.友元函数

    • 友元函数在类作用域外定义,但它需要在类体中进行说明
    • 为了与该类的成员函数加以区别,定义的方式是在类中用关键字friend说明该函数,格式如下:
    friend  类型 友元函数名(参数表);
    
    • 友元的作用在于提高程序的运行效率

    3.友元函数注意事项

    • 友元函数不是类的成员函数,在函数体中访问对象的成员,必须用对象名加运算符“.”加对象成员名。但友元函数可以访问类中的所有成员(公有的、私有的、保护的),一般函数只能访问类中的公有成员。

    • 友元函数不受类中的访问权限关键字限制,可以把它放在类的公有、私有、保护部分,但结果一样。

    • 某类的友元函数的作用域并非该类作用域。如果该友元函数是另一类的成员函数,则其作用域为另一类的作用域,否则与一般函数相同。

    • 友元函数破坏了面向对象程序设计类的封装性,所以友元函数如不是必须使用,则尽可能少用。或者用其他手段保证封装性。

    • eg:21cpp\21cpp\21cpp\01.cpp

    #include <math.h>
    #include <iostream>
    using namespace std;
    
    class Point
    {
    	//Distance函数不是Point类的成员函数
    	friend double Distance(const Point& p1, const Point& p2);
    public:
    	Point(int x, int y);
    private:
    	//friend double Distance(const Point& p1, const Point& p2);防着也行
    	int x_;
    	int y_;
    };
    
    Point::Point(int x, int y) : x_(x), y_(y)
    {
    
    }
    
    //Distance友元函数的作用域在类体之外,就算在类体里面定义
    //友元函数可以访问类的私有成员
    //友元函数的作用域与main一样,都是全局的
    double Distance(const Point& p1, const Point& p2)
    {
    	double dx = p1.x_ - p2.x_;
    	double dy = p1.y_ - p2.y_;
    
    	return sqrt(dx*dx + dy*dy);
    }
    
    int main(void)
    {
    	Point p1(3, 4);
    	Point p2(6, 8);
    
    	cout<<Distance(p1, p2)<<endl;
    	return 0;
    }
    
    
    • 测试:
      在这里插入图片描述

    4.友元类

    • 如果某类B的成员函数会频繁的存取另一个类A的数据成员, 而A的数据成员的Private/Protectd限制造成B存取的麻烦, B只能通过A的Public的成员函数进行间接存取
    • 把B做成A类的友元类,即A类向B类开发其Private/Protectd内容, 让B直接存取
    • 友元类:一个类可以作另一个类的友元
    • 友元类的所有成员函数都是另一个类的友元函数
    • 友元类的声名:
    friend class 类名;
    

    5.友元类注意事项

    • 友元关系是单向的
      A是B的友元类(在B类中 friend class A),并不代表B也是A的友元类

    • 友元关系不能被传递
      A是B的友元类,B是C友元类,并不代表A是C的友元类

    • 友元关系不能被继承
      A是B的友元类,C继承自A,并不代表C是B的友元类

    • eg:21cpp\21cpp\21cpp\02.cpp
      电视机和遥控器的eg
      遥控器能控制电视机的音量和频道

    #include "Television.h"
    #include "TeleController.h"
    #include <iostream>
    using namespace std;
    
    
    int main(void)
    {
    	Television tv(1, 1);
    
    	TeleController tc;
    	tc.VolumeUp(tv);
    
    	return 0;
    }
    
    • 类声明及定义
      21cpp\21cpp\21cpp\Television.h
    #ifndef _TELEVISION_H_
    #define _TELEVISION_H_
    
    //有的编译器对TeleController不可见,则加上下面的前向声明即可
    class TeleController;
    
    class Television
    {
    	//将TeleController遥控器类声明为Television电视机类的友元类
    	friend class TeleController;
    public:
    	Television(int volume, int chanel);
    private:
    	int volume_;//声音
    	int chanel_;//频道
    };
    
    #endif // _TELEVISION_H_
    
    

    21cpp\21cpp\21cpp\Television.cpp

    #include "Television.h"
    
    Television::Television(int volume, int chanel) : volume_(volume), chanel_(chanel)
    {
    
    }
    

    21cpp\21cpp\21cpp\TeleController.h

    #ifndef  _TELE_CONTROLLER_H_
    #define _TELE_CONTROLLER_H_
    
    //有的编译器对Television中不可见,则加上下面的前向声明即可,因为这里只是一个引用,并没有定义对象
    //还要在TeleController.cpp文件中增加#include "Television.h"
    class Television;
    
    class TeleController
    {
    public:
    	void VolumeUp(Television& tv);
    
    	void VolumeDown(Television& tv);
    
    	void ChanelUp(Television& tv);
    
    	void ChanelDown(Television& tv);
    };
    
    #endif // _TELE_CONTROLLER_H_
    

    21cpp\21cpp\21cpp\TeleController.cpp

    #include "TeleController.h"
    #include "Television.h"
    
    void TeleController::VolumeUp(Television& tv)
    {
    	tv.volume_ += 1;
    }
    
    void TeleController::VolumeDown(Television& tv)
    {
    	tv.volume_ -= 1;
    }
    
    void TeleController::ChanelUp(Television& tv)
    {
    	tv.chanel_ += 1;
    }
    
    void TeleController::ChanelDown(Television& tv)
    {
    	tv.volume_ -= 1;
    }
    
    • 测试:无
    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,457
精华内容 3,782
关键字:

友元类