友元类_友元类声明 - CSDN
精华内容
参与话题
  • C++ 友元类

    千次阅读 2018-11-08 14:58:18
    1.定义: 当一个B成为了另外一个A的“朋友”时,那么A的私有和保护的数据成员就可以被B访问。我们就把B叫做A的友元。 2.注意事项:值得提醒的是友员关系是单项关系,但是如果要相互作用的话,需要设置...

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

    2.注意事项:值得提醒的是友员关系是单项关系,但是如果要相互作用的话,需要设置相互关系,这种关系在现实生活中的朋友关系差别有点大,呵呵~,而且这种关系尽量避免。

    3.具体代码:

    例一.

    #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;
    }

     

    例二.

    #include <iostream>
    #include <cstring>
    using namespace std ;
    //声明教师类 
    class Techer ;
    //学生类 
    class Student 
    {
        private:
            string name ;
            int age ;    
            char sex ; 
            int score ; 
        public :
            Student(string name , int age , char sex , int score);
            void stu_print(Techer &tech);
    };
    //教师类 
    class Techer
    {
        private:
            string name ;
            int age ;    
            char sex ; 
            int score ; 
        public :
            Techer(string name , int age , char sex , int score);
            //声明一个友元类
            friend Student ;
    };
     
    //Student类的构造函数的实现 
    Student::Student(string name , int age , char sex , int score)
    {
        this->name = name ; 
        this->age = age ; 
        this->sex = sex ; 
        this->score = score ;
    }
    //Techer类的构造函数的实现
    Techer::Techer(string name , int age , char sex , int score)
    {
        this->name = name ; 
        this->age = age ; 
        this->sex = sex ; 
        this->score = score ;
    }
     
    //打印Student类中的私有成员和Techer的私有成员 
    void Student::stu_print(Techer &tech)
    {
        //用this指针访问本类的成员 
        cout << this->name << endl ; 
        cout << this->age << endl ; 
        cout << this->sex << endl ; 
        cout << this->score << endl ;
        //访问Techer类的成员 
        cout << tech.name << endl ;
        cout << tech.age << endl ; 
        cout << tech.sex << endl ; 
        cout << tech.score << endl ;
    }
     
    int main(void)
    {
        Student stu1("YYX",24,'N',86);
        Techer t1("hou",40,'N',99);
        stu1.stu_print(t1);
        return 0 ;
    }
     

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

    万次阅读 多人点赞 2018-01-21 21:12:37
    在C++中,我们使用类对数据进行了隐藏和封装,类的数据成员一般都...除了友元函数外,还有友元类,两者统称为友元。友元的作用是提高了程序的运行效率(即减少了类型检查和安全性检查等都需要时间开销),但它破坏了类

     在C++中,我们使用类对数据进行了隐藏和封装,类的数据成员一般都定义为私有成员,成员函数一般都定义为公有的,以此提供类与外界的通讯接口。但是,有时需要定义一些函数,这些函数不是类的一部分,但又需要频繁地访问类的数据成员,这时可以将这些函数定义为该函数的友元函数。除了友元函数外,还有友元类,两者统称为友元。友元的作用是提高了程序的运行效率(即减少了类型检查和安全性检查等都需要时间开销),但它破坏了类的封装性和隐藏性,使得非成员函数可以访问类的私有成员。

    友元函数 : 
           友元函数是可以直接访问类的私有成员的非成员函数。它是定义在类外的普通函数,它不属于任何类,但需要在类的定义中加以声明,声明时只需在友元的名称前加上关键字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的友元,同样要看类中是否有相应的申明
    《windows环境多线程编程原理与应用》中解释:
      如果将类的封装比喻成一堵墙的话,那么友元机制就像墙上了开了一个门,那些得
      到允许的类或函数允许通过这个门访问一般的类或者函数无法访问的私有属性和方   
      法。友元机制使类的封装性得到消弱,所以使用时一定要慎重。

    友元类:

    将外界的某个类在本类别的定义中说明为友元,那么外界的类就成为本类的“朋  
       友”,那个类就可以访问本类的私有数据了。
       class Merchant
          {
              private :
                 int m_MyMoney;
                 int m_MyRoom;
                 … …
              Public:
                 Friend class Lawyer;
                 Int getmoney();
                 … …
          };
          Class Lawyer
         {
            Private:
              … …
            Public:
             … …
         };
         只有你赋予某个类为你的友元时,那个类才有访问你的私有数据的权利。说明一个函数为一个类的友元函数则该函数可以访问此类的私有数据和方法。定义方法是在类的定义中,在函数名前加上关键字friend.

    需要友元与友元的优缺点: 

           通常对于普通函数来说,要访问类的保护成员是不可能的,如果想这么做那么必须把类的成员都生命成为public(共用的),然而这做带来的问题遍是任何外部函数都可以毫无约束的访问它操作它,c++利用friend修饰符,可以让一些你设定的函数能够对这些保护数据进行操作,避免把类成员全部设置成public,最大限度的保护数据成员的安全。 

            友元能够使得普通函数直接访问类的保护数据,避免了类成员函数的频繁调用,可以节约处理器开销,提高程序的效率,但所矛盾的是,即使是最大限度大保护,同样也破坏了类的封装特性,这即是友元的缺点,在现在cpu速度越来越快的今天我们并不推荐使用它,但它作为c++一个必要的知识点,一个完整的组成部分,我们还是需要讨论一下的。 在类里声明一个普通数学,在前面加上friend修饰,那么这个函数就成了该类的友元,可以访问该类的一切成员。

            下面我们来看一段代码,看看我们是如何利用友元来访问类的一切成员的:

    #include <iostream> 
    using namespace std; 
    class Internet 
    { 
    public: 
    Internet(char *name,char *address) // 改为:internet(const char *name , const char *address)
    { 
    strcpy(Internet::name,name); 
    strcpy(Internet::address,address); 
    } 
    friend void ShowN(Internet &obj);   //友元函数的声明 
    public:              // 改为:private
    char name[20]; 
    char address[20]; 
    }; 
    void ShowN(Internet &obj)        //类外普通函数定义,访问a对象的保护成员name,不能写成,void Internet::ShowN(Internet &obj) 
    { 
    cout<<obj.name<<endl;          //可访问internet类中的成员
    } 
    void main() 
    { 
    Internet a("谷歌","http://www.google.cn/";); 
    ShowN(a); 
    cin.get(); 
    } 
    
          示例2:

          分别定义一个类A和类B ,各有一个私有整数成员变量通过构造函数初始化;类A有一个成员函数Show(B &b)用来打印A和B的私有成员变量,请分别通过友元函数和友元类来实现此功能。使用友元类 和 友元函数实现:

    #include <iostream>
    
    using namespace std;
    class B;
    class A;
    void Show( A& , B& );
    
    class B
    {
    private:
    int tt;
    friend class A;
    friend void Show( A& , B& );
    
    public:
    B( int temp = 100):tt ( temp ){}
    
    };
    
    class A
    {
    private:
    int value;
    friend void Show( A& , B& );
    
    public:
    A(int temp = 200 ):value ( temp ){}
    
    void Show( B &b )
    {
      cout << value << endl;
      cout << b.tt << endl; 
    }
    };
    
    void Show( A& a, B& b )
    {
    cout << a.value << endl;
    cout << b .tt << endl;
    }
    
    int main()
    {
    A a;
    B b;
    a.Show( b );
    Show( a, b );
          return 0;
    }
    



    展开全文
  • C++友元类的三种实现方式 class对象中的成员分为public类与private类,前者可以定义class变量后直接访问,而后者则不可以访问 通过引入友元(friend)达到访问private类的成员 1.1 全局函数做友元 定义全局函数,...

    C++友元类的三种实现方式

    • class对象中的成员分为public类与private类,前者可以定义class变量后直接访问,而后者则不可以访问
    • 通过引入友元(friend)达到访问private类的成员

    1.1 全局函数做友元

    • 定义全局函数,将全局函数在class对象中进行friend调用
    class Building
    {
    	//告诉编译器 goodGay全局函数 是 Building类的好朋友,可以访问类中的私有内容
    	friend void goodGay(Building * building);
    
    public:
    
    	Building()
    	{
    		this->m_SittingRoom = "客厅";
    		this->m_BedRoom = "卧室";
    	}
    
    
    public:
    	string m_SittingRoom; //客厅
    
    private:
    	string m_BedRoom; //卧室
    };
    
    
    void goodGay(Building * building)
    {
    	cout << "好基友正在访问: " << building->m_SittingRoom << endl;
    	cout << "好基友正在访问: " << building->m_BedRoom << endl;
    }
    
    
    void test01()
    {
    	Building b;
    	goodGay(&b);
    }
    
    int main(){
    
    	test01();
    
    	system("pause");
    	return 0;
    }
    

    1.2类做友元

    • 定义一个class类,对类进行friend调用
    • class类中的成员可以进行类外调用——Building::Building()——返回类型+class类::函数成员
    class Building;
    class goodGay
    {
    public:
    
    	goodGay();
    	void visit();
    
    private:
    	Building *building;
    };
    
    
    class Building
    {
    	//告诉编译器 goodGay类是Building类的好朋友,可以访问到Building类中私有内容
    	friend class goodGay;
    
    public:
    	Building();
    
    public:
    	string m_SittingRoom; //客厅
    private:
    	string m_BedRoom;//卧室
    };
    
    Building::Building()
    {
    	this->m_SittingRoom = "客厅";
    	this->m_BedRoom = "卧室";
    }
    
    goodGay::goodGay()
    {
    	building = new Building;
    }
    
    void goodGay::visit()
    {
    	cout << "好基友正在访问" << building->m_SittingRoom << endl;
    	cout << "好基友正在访问" << building->m_BedRoom << endl;
    }
    
    void test01()
    {
    	goodGay gg;
    	gg.visit();
    
    }
    
    int main(){
    
    	test01();
    
    	system("pause");
    	return 0;
    }
    

    1.3成员函数做友元

    • 单独的调用其他类中的成员函数,对其friend操作:friend 返回类型 class类::成员函数
    class Building;
    class goodGay
    {
    public:
    
    	goodGay();
    	void visit(); //只让visit函数作为Building的好朋友,可以发访问Building中私有内容
    	void visit2(); 
    
    private:
    	Building *building;
    };
    
    
    class Building
    {
    	//告诉编译器  goodGay类中的visit成员函数 是Building好朋友,可以访问私有内容
    	friend void goodGay::visit();
    
    public:
    	Building();
    
    public:
    	string m_SittingRoom; //客厅
    private:
    	string m_BedRoom;//卧室
    };
    
    Building::Building()
    {
    	this->m_SittingRoom = "客厅";
    	this->m_BedRoom = "卧室";
    }
    
    goodGay::goodGay()
    {
    	building = new Building;
    }
    
    void goodGay::visit()
    {
    	cout << "好基友正在访问" << building->m_SittingRoom << endl;
    	cout << "好基友正在访问" << building->m_BedRoom << endl;
    }
    
    void goodGay::visit2()
    {
    	cout << "好基友正在访问" << building->m_SittingRoom << endl;
    	//cout << "好基友正在访问" << building->m_BedRoom << endl;
    }
    
    void test01()
    {
    	goodGay  gg;
    	gg.visit();
    
    }
    
    int main(){
        
    	test01();
    
    	system("pause");
    	return 0;
    }
    
    展开全文
  • C++之:友元类

    千次阅读 2016-03-11 09:43:39
    一、文章来由上一篇写了友元函数,这一次写一个姊妹篇,继续深入探究一下友元类。二、定义 友元类的所有成员函数都是另一个类的友元函数,都可以访问另一个类中的隐藏信息(包括私有成员和保护成员)。 当希望一个...

    一、文章来由

    上一篇写了友元函数,这一次写一个姊妹篇,继续深入探究一下友元类。

    二、定义

    友元类的所有成员函数都是另一个类的友元函数,都可以访问另一个类中的隐藏信息(包括私有成员和保护成员)。

    当希望一个类可以存取另一个类的私有成员时,可以将该类声明为另一类的友元类。定义友元类的语句格式如下:

    friend class 类名;

    其中:friend和class是关键字,类名必须是程序中的一个已定义过的类。

    三、例子

    #include <iostream>
    using namespace std;
    
    class Radius
    {
        friend class Circle;   //声明Circle为Radius的友元类
        friend void Show_r(Radius &n);     //声明Show_r为友元函数
    
    public:
    Radius(int x)
    {
        r = x;
    }
    ~Radius()
    {
    }
    
    private:
        int r;
    };
    
    void Show_r(Radius &n)
    {
        cout<<"圆的半径为: "<<n.r<<endl;    //调用Radius对象的私有成员变量r
    }
    
    class Circle
    {
    public:
        Circle(){}
        ~Circle(){}
    
    double area(Radius a)
    {
        s = a.r * a.r * 3.1415926;             //调用Radius对象的私有成员变量r
        return s;
    }
    
    private:
        double s;
    };
    
    int main(int argc, char *argv[])
    {
        Radius objRadius(9);
        Circle objCircle;
    
        Show_r( objRadius );
        cout<<"面积为:"<<objCircle.area(objRadius)<<endl;
    
        return 0;
    }
    展开全文
  • 友元类

    千次阅读 2012-07-10 11:15:01
    error: is private 如果添加了friend之后,还是报错的话。不妨看看是不是名字空间搞错了。
  • 友元类的使用

    2019-02-15 17:44:39
    #include&lt;iostream&gt; #include&lt;math.h&gt; using namespace std; class Point { private: double x; double y; public: Point(double a,double b) { ...
  • 有些情况下,允许特定的非成员函数访问一个的私有...友元的声明以friend开始,它只能出现在定义的内部,友元声明可以出现在中的任何地方 友元不是授予友元关系的那个的成员,所以它们不受其声明出现部分...
  • 1、为什么要引入友元函数:在实现之间数据共享时,减少系统开销,提高效率 具体来说:为了使其他的成员函数直接访问该的私有变量 即:允许外面的或函数去访问的私有变量和保护变量,从而使两个共享同一...
  • 在学习C++之初就知道有友元的概念,但是它到底有什么用,什么时候是合适的应用时机一直不太明确. 简单描述一下其应用场景. 现在有一个图元Gp,在绘制的过程中可能会用到N多的成员变更,如是否显示颜色,点大小,线...
  • 定义: 当一个类B成为了另外一个类A的“朋友”时,那么类A的私有和保护的数据成员...下面这个程序说明了友元类与友元派生类的权限。 class A { public: friend class FriendA; private: int a; }; class Frien...
  • 我们在设计类时,一般...为了能够访问类私有成员,我们可以采用友元函数,在c++中以关键字friend加以声明,友元可以包括友元函数和友元类;友元函数又可以分为友元函数和友元成员函数;其一般形式分别如下:友元函数:
  • C++ 类(友元函数和友元类)

    千次阅读 2018-07-19 16:56:20
    2.友元类 我们知道类的私有属性只能在类的内部访问, 能不能通过一种途径可以在类的外部访问? 答案是有的,友元函数。 友元函数 a. 友元函数的作用: 可以在类的外部访问类的私有属性,但是会破坏类的封装。 b. ...
  • 一、友元函数介绍 ...可以把一个函数指定为友元,也可以把整个指定为另一个友元。 二、友元函数 友元函数在作用域外定义,但它需要在体中进行说明,为了与该的成员函数加以区
  • C++ 设计者认为, 如果有的程序员真的非常怕麻烦,就是想在的成员函数外部直接访问对象的私有成员,那还是做一点妥协以满足他们的愿望为好,这也算是眼前利益和长远利益的折中。因此,C++ 就有了友元(friend)的...
  • C++友元类

    千次阅读 2020-05-15 23:14:12
    C++友元类
  • C++友元类例子

    2019-09-16 10:02:15
    友元类: classA { public: friendclassB;//B是A的成员函数所以B得成员函数可以通过A的对象访问A的保护和私有成员 intaa; private: intaaa; }; classB { public: intdd; voidprinf() { a.aaa=3;//可以访问A的...
  • 友元函数 友元类 友元成员函数

    千次阅读 2018-05-07 22:34:40
    一般来说,内的私有数据是对外不可见的,但在有些情况下,我们需要在外对该的私有数据进行访问,这就需要用到一种新技术——友元(friend),即在声明前添加关键字friend。 友元关系是单向的,即如果A是B的...
  • c++友元类声明及其调用

    千次阅读 2017-09-26 11:21:17
    c++友元类的相关理解及定义使用!!!
  • 友元类与继承

    千次阅读 2012-04-17 20:41:54
    C++ Primer中有如下描述:友元关系不能继承。基类的友元对派生类的成员没有特殊访问 权限。如果基类被授予友元关系,则只有基类具有特殊访问权限,该基类的派生类不能...1 友元类的继承问题 1.1 A类的友元B的派生类C
1 2 3 4 5 ... 20
收藏数 37,728
精华内容 15,091
关键字:

友元类