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

    2016-07-17 23:17:54
    C++ 友元

    编译器采用mingw32-g++ c++11,编辑器为codeblocks
    如果一个类想要其他类或者函数能够访问这个类的非公有成员,那么可以采用友元的方式。

    友元函数:
    如果想让某个非成员函数能够操作类中的私有成员,可以在这个中声明这个函数,并且在函数的前面表上friend的关键字。一般来说,最好再类定义开始或结束前的位置集中声明友元。

    class A
    {
        friend void fun(A &a);
    public:
        string member2;
    private:
        int member1;
    };
    void fun(A &a)//此函数可以使用class A中的私有成员
    {
        a.member1=0;
    }

    友元类:
    简单点说就是一个类可以使用另外一个类当中的私有成员。如果想在类A当中使用类B当中的私有成员,那么需要在类B当中声明friend class A;
    同时要注意,友元关系不具有传递性质。

    class B
    {
        friend class A;
    private:
        int member1;
    };
    class A
    {
    public:
        string member2;
        void fun(B &b)
        {
            b.member1++;
        }
    private:
        int member1;
    };

    类中的成员函数作为友元:
    把一个成员函数声明成友元时,必须要明确指出该成员函数属于哪个类。例如在类A当中又一个成员函数fun()要使用类B当中的私有成员,需要按照以下步骤执行。
    1.首先前向声明类B
    2.定义类A,声明类A当中的fun()函数,但是不能定义fun()函数
    3.接下来定义类B,同时声明类A当中的友元函数
    4.定义fun函数

    class B;
    class A
    {
    public:
        string member2;
        void fun(B &b);
    private:
        int member1;
    };
    class B
    {
        friend void A::fun(B &b);
    private:
        int member1;
    };
    void A::fun(B& b)
    {
        b.member1++;
    }

    友元的声明和作用域:
    友元函数可以直接在类中声明+定义。

    class B
    {
        friend void f(B &b)
        {
            b.m2=0;
        }
    public:
        void get_m2(){cout<<this->m2<<endl;}
        string m1;
    private:
        int m2;
    };
    int main()
    {
        ios::sync_with_stdio(false);
        B b;
        f(b);
        b.get_m2();
        return 0;
    }

    要想再类中调用fun,那么必须先声明,否则会报错。

    class B//会报错
    {
        friend void f(B &b)
        {
            b.m2=0;
        }
    public:
        void get_m2(){cout<<this->m2<<endl;}
        string m1;
        B()
        {
            f();
        }
    private:
        int m2;
    };
    
    
    void f();//添加声明
    class B
    {
        friend void f(B &b)
        {
            b.m2=0;
        }
    public:
        void get_m2(){cout<<this->m2<<endl;}
        string m1;
        B()
        {
            f();
        }
    private:
        int m2;
    };

    这里注意,有的编译器不会强制执行上诉关于友元的限定规则。(书上如是说)

    展开全文
  • C++友元

    2015-03-19 11:33:16
    c++ 友元

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

      为了解决上述问题,提出一种使用友元的方案。友元是一种定义在类外部的普通函数,但他需要在类体内进行说 明,为了和该类的成员函数加以区别,在说明时前面加以关键字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)是友元函数的调用,他直接调 用,无需对象表示,他的参数是对象。(该程式的功能是已知两点坐标,求出两点的距离。)

    友元类

      当一个类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;
    }
    展开全文
  • c++ 友元

    2019-03-26 14:29:53
    友元(友元函数、友元类和友元成员函数) C++ 友元(frend)机制允许一个类将对其非公有成员的访问权授予指定的函数或者类,友元的声明以friend开始,它只能出现在类定义的内部,友元声明可以出现在类中的任何地方:...

    友元(友元函数、友元类和友元成员函数) C++

    友元(frend)机制允许一个类将对其非公有成员的访问权授予指定的函数或者类,友元的声明以friend开始,它只能出现在类定义的内部,友元声明可以出现在类中的任何地方:友元不是授予友元关系的那个类的成员,所以它们不受其声明出现部分的访问控制影响。通常,将友元声明成组地放在类定义的开始或结尾是个好主意。

    1、友元函数

     友元函数是指非类成员却能够访问类的所有成员的函数。

    在类定义中声明一个:friend 标识的函数,该函数为友元函数。

    #include <iostream>
    using namespace std;
    
    class friendclass
    {
    public:
    	int ia;
    	friend void show(int x,friendclass &friendC);
    private:
    	int idata;	
    };
    
    void show(int x,friendclass &friendC)
    {
    	 friendC.idata = x;
    	cout << friendC.idata<<endl;
    }
    
    
    int main()
    {	
    	friendclass friendc;
    	show(3,friendc);
       return 0;
    }

    2、友元类

    友元类的所有成员函数都是另一个类的友元函数,都可以访问另一个类中的隐藏信息(包括私有成员和保护成员)。当希望一个类可以存取另一个类的私有成员时,可以将该类声明为另一类的友元类。

    关于友元类的注意事项:

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

    #include <iostream>
    using namespace std;
    class friendclassb;
    class friendclassa
    {
    public:
    	friend friendclassb;
    	int ia;
    	//void show(int x);
    	friendclassa(int idata_):idata(idata_){};
    private:
    	int idata;	
    };
    
    
    
    class friendclassb
    {
    public:
    	int ib;
    	void show(friendclassa &friendA);
    	private:
    	int idata;
    };
    
    void friendclassb::show(friendclassa &friendA)
    {
    	cout<<friendA.idata<<endl;
    	
    }
    int main()
    {	
    	friendclassa frienda(5);
    	friendclassb friendb;
    	friendb.show(frienda);
       return 0;
    }

     

    3、友元成员函数

    使类B中的成员函数成为类A的友元函数,这样类B的该成员函数就可以访问类A的所有成员了。

     当用到友元成员函数时,需注意友元声明和友元定义之间的相互依赖,在该例子中,类B必须先定义,否则类A就不能将一个B的函数指定为友元。然而,只有在定义了类A之后,才能定义类B的该成员函数。更一般的讲,必须先定义包含成员函数的类,才能将成员函数设为友元。另一方面,不必预先声明类和非成员函数来将它们设为友元。

    #include <iostream>
    
    using namespace std;
    
    class A;    //当用到友元成员函数时,需注意友元声明与友元定义之间的互相依赖。这是类A的声明
    class B
    {
    public:
        void set_show(int x, A &a);             //该函数是类A的友元函数
    };
    
    class A
    {
    public:
        friend void B::set_show(int x, A &a);   //该函数是友元成员函数的声明
    private:
        int data;
        void show() { cout << data << endl; }
    };
    
    void B::set_show(int x, A &a)       //只有在定义类A后才能定义该函数,毕竟,它被设为友元是为了访问类A的成员
    {
        a.data = x;
        cout << a.data << endl;
    }
    
    int main(void)
    {
        class A a;
        class B b;
    
        b.set_show(1, a);
    
        return 0;
    }

    在需要允许某些特定的非成员函数访问一个类的私有成员(及受保护成员),而同时仍阻止一般的访问的情况下,友元是可用的。

    优点:

            可以灵活地实现需要访问若干类的私有或受保护的成员才能完成的任务;

            便于与其他不支持类概念的语言(如C语言、汇编等)进行混合编程;

            通过使用友元函数重载可以更自然地使用C++语言的IO流库。

    缺点:

            一个类将对其非公有成员的访问权限授予其他函数或者类,会破坏该类的封装性,降低该类的可靠性和可维护性。

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

    展开全文
  • c++友元

    2016-05-18 16:05:32
    尽管友元被授予从外部访问类的私有部分的权限,但他们并不与面向...我直接贴出一个摘自< c++ primer plus >的例子来演示 c++ 友元类 其中 Remote 为 Tv的友元类。 Tv.h#ifndef TV_H_ #define TV_H_/*一个类 电视 */

    尽管友元被授予从外部访问类的私有部分的权限,但他们并不与面向对象的编程思想相悖;相反他提高了公共接口的灵活性。

    一、友元类
    友元声明可以位于公有、私有活保护部分、其所在位置无关紧要
    我直接贴出一个摘自< c++ primer plus >的例子来演示 c++ 友元类
    其中 Remote 为 Tv的友元类。
    Tv.h

    #ifndef TV_H_
    #define TV_H_
    
    /*一个类 电视  */
    class Tv
    {
    public:
        friend class Remote;  //Remote类可以访问Tv Privite 的私有部分
        enum {
            off,on   //开关  
        };
        enum 
        {
            MinVal,MaxVal=20   //音量
        };
        enum {
            Antena,Cable  //使用的天线、还是电缆
        };
        enum 
        {
            TV ,DVD   //工作模式
        };
    
        Tv(int s = off, int mc = 125) :state(s), volume(5), maxchannel(mc),
            channel(5), mode(Cable), input(TV) {}
        void onoff() { state = (state == on) ? off : on; }
        bool ison()const { return state == on; }
        bool volup();   //增大声音
        bool voldown(); //减小声音
        void chanup();  //频道 +
        void chandown();//频道 -
        void set_mode() { mode = (mode == Antena) ? Cable : Antena; }
        void set_input() { input = (input == TV) ? DVD : TV; }
        void settings()const; //显示所有设置
    
    
    private:
        int state;   // 开或者 关
        int volume; // 音量
        int maxchannel;  //最大
        int channel;   //当前频道
        int mode;   //  广播还是 电缆
        int input; //Tv  或者 DVD
    };
    
    /*Remote 的定义 (遥控器) */
    class Remote {
    private :
        int mode; // 控制 TV 或 DVD
    public:
        Remote(int m = Tv::TV) :mode(m) {}
        bool volup(Tv & t) { return t.volup(); }
        bool voldown(Tv & t) { return t.voldown(); }
        void onoff(Tv & t) { return t.onoff(); }
        void chanup(Tv & t) { return t.chanup(); }
        void chandown(Tv & t) { return t.chandown(); }
        void set_chan(Tv &t, int c) { t.channel = c; } //访问了Tv的私有成员
        void set_mode(Tv &t) { t.set_mode(); }
        void set_input(Tv &t) { t.set_input(); }
    };
    #endif // TV_H_

    Tv.cpp

    #include "stdafx.h"
    #include "Tv.h"
    #include <iostream>
    
    bool Tv::volup() {
        if (volume < MaxVal) {
            volume++;
            return true;
        }
        else {
            return false;
        }
    }
    
    bool Tv::voldown() {
        if (volume > MinVal) {
            volume--;
            return true;
        }
        else {
            return false;
        }
    }
    
    void Tv::chanup() {
        if (channel < maxchannel) channel++;
        else channel = 1;
    }
    
    void Tv::chandown() {
        if (channel > 1) channel--;
        else channel = maxchannel;
    }
    
    void Tv::settings() const {
        using std::cout;
        using std::endl;
        cout << "TV is " << (state == off ? "off" : "on") << endl;
        if (state == on) {
            cout << "Volume setting =" << volume << endl;
            cout << "Channel setting = " << channel << endl;
            cout << "Mode = " << (mode == Antena ? "antenna" : "cable") << endl;
            cout << "Input = " << (input == TV ? "TV" : "DVD") << endl;
        }
    }

    测试代码:

    #include "stdafx.h"
    #include "tv.h"
    #include <iostream>
    
    int main()
    {
        using std::cout;
        Tv s42;
        cout << "Initial settings for 42 \" Tv: \n";
        s42.settings();
        s42.onoff();
        s42.chanup();
    
        cout << " \n Adjusted settings for 42 \" Tv: \n";
        s42.chanup();
        cout << "\n Adjusted settings for 42 \" Tv: \n";
        s42.settings();
    
        Remote grey;
        grey.set_chan(s42, 10);
        grey.volup(s42);
        grey.volup(s42);
        cout << " \n s42 \" settings after using remote: \n";
        s42.settings();
    
        Tv s58(Tv::on);
        s58.set_mode();
        grey.set_chan(s58, 58);
        cout << " \n s58 \" setting: \n";
        s58.settings();
    
        system("pause");
        return 0;
    }
    运行结果:
    Initial settings for 42 " Tv:
    TV is off
    
     Adjusted settings for 42 " Tv:
    
     Adjusted settings for 42 " Tv:
    TV is on
    Volume setting =5
    Channel setting = 7
    Mode = cable
    Input = TV
    
     s42 " settings after using remote:
    TV is on
    Volume setting =7
    Channel setting = 10
    Mode = cable
    Input = TV
    
     s58 " setting:
    TV is on
    Volume setting =5
    Channel setting = 58
    Mode = antenna
    Input = TV
    请按任意键继续. . .
    

    上述代码中将Remote类设置成为了Tv类的友元类,但事实上我们看到:唯一访问Tv的成员的方法是void set_chan(Tv &t, int c) { t.channel = c; } ,因此它是唯一需要友元的方法。因此不必让整个类成为友元,这就引出了我们下面要讲的的友元成员函数。

    二、友元成员函数
    我们要再Tv中将Remote::set_chan()设置成友元:

    clas Tv
    {
        friend void Remote::set_chan(Tv & t,int c ) ;
    }

    然而要使编译器能够处理这条语句,它必须知道Remote的定义。否则,它无法知道Remote是一个类。而 set_chan是这个类的方法。这意味着应将Remote的定义放到Tv的定义前面。Remote的方法提到了Tv对象,而意味着Tv定义应当位于Remote定义之前,避开这种循环依赖的方法是,使用前向声明。
    所以应该这样:

    class Tv ; //前向声明
    class Remote{...}
    class Tv {...}

    这里还有一个麻烦就是:
    Remote 包含了内联代码例如:void onoff(Tv &t) {t.onoff();};
    由于这将调用Tv的一个方法,所以编译器此时已经看到了Tv类的声明,这样才能知道Tv有哪些方法,但正如看到的,该声明位于Remote声明的后面。这种问题的解决方法是:使用Remote声明中只包含方法声明,并将实际的定义放到Tv类之后。 所以最终应该这样:

    class Tv;  //前向声明
    class Remote {...} //如要用到Tv 只能是方法声明
    class Tv{...}
    //接着写Remote的定义
    • 这里通过方法定义中使用 inline关键字,仍然可以使方法称为内联方法

    所以程序最终将tv.h改为:

    #ifndef TV_H_
    #define TV_H_
    class Tv;  //前向声明
    class Remote {
    
    public:
        enum {
            off, on   //开关  
        };
        enum
        {
            MinVal, MaxVal = 20   //音量
        };
        enum {
            Antena, Cable  //使用的天线、还是电缆
        };
        enum
        {
            TV, DVD   //工作模式
        };
    
    private:
        int mode; // 控制 TV 或 DVD
    public:
        Remote(int m = TV) :mode(m) {}
        //用到了Tv  只能是声明
        bool volup(Tv & t);
        bool voldown(Tv & t);
        void onoff(Tv & t);
        void chanup(Tv & t);
        void chandown(Tv & t);
        void set_chan(Tv &t, int c);
        void set_mode(Tv &t);
        void set_input(Tv &t);
    };
    
    class Tv
    {
    public:
        friend void Remote::set_chan(Tv & t,int c);  //友元成员函数
        enum {
            off, on   //开关  
        };
        enum
        {
            MinVal, MaxVal = 20   //音量
        };
        enum {
            Antena, Cable  //使用的天线、还是电缆
        };
        enum
        {
            TV, DVD   //工作模式
        };
        Tv(int s = off, int mc = 125) :state(s), volume(5), maxchannel(mc),
            channel(5), mode(Cable), input(TV) {}
        void onoff() { state = (state == on) ? off : on; }
        bool ison()const { return state == on; }
        bool volup();   //增大声音
        bool voldown(); //减小声音
        void chanup();  //频道 +
        void chandown();//频道 -
        void set_mode() { mode = (mode == Antena) ? Cable : Antena; }
        void set_input() { input = (input == TV) ? DVD : TV; }
        void settings()const; //显示所有设置
    private:
        int state;   // 开或者 关
        int volume; // 音量
        int maxchannel;  //最大
        int channel;   //当前频道
        int mode;   //  广播还是 电缆
        int input; //Tv  或者 DVD
    };
    
    inline bool Remote::volup(Tv & t) { return t.volup(); }
    inline bool Remote::voldown(Tv & t) { return t.voldown(); }
    inline void Remote::onoff(Tv & t) { return t.onoff(); }
    inline void Remote::chanup(Tv & t) { return t.chanup(); }
    inline void Remote::chandown(Tv & t) { return t.chandown(); }
    inline void Remote::set_chan(Tv &t, int c) { t.channel = c; }
    inline void Remote::set_mode(Tv &t) { return t.set_mode(); }
    inline void Remote::set_input(Tv &t) { return t.set_input(); }
    #endif // TV_H_
    
    
    

    测试结果不变。
    *另外:也可一个将内联函数放在tv.cpp中,但必须去掉inline关键字,这样函数的连接性将成为外部的。
    三、其他友元关系
    1、上面的代码表示的是Remote是Tv的友元。但我们有时也会用到2个类互相友元。即Remote是Tv的友元,同时 Tv又是Remote的友元
    他们定义与下面类似:

    class Remote
    class Tv
    {
    friend clas Remote
    public:
        void buzz(Remote & r) ;
        ...
    }
    
    class Remote
    {
    friend class Tv;
    public:
        void Bool volup(Tv & t){t.volup();}
        ...
    }
    inline void Tv::buzz(Remote & r)
    {
    ...
    }

    由于Remote的声明位于Tv声明的后面,所以可以在类的定义Remote::volup(),但Tv::buzz()方法必须在Tv声明的外部定义,使其位于Remote声明的外面。如果不希望buzz()是内联的,则应在一个单独的方法定义文件中定义它。
    2、共同的友元。
    需要使用友元的另一种情况是,函数需要访问两个类的私有数据。它可以是一个类的友元,同时是另一个类的友元。示例如下:

    class Analyzer;
    class Probe
    {
        friend void sync (Analyzer & a,const Probe & p) ;
        friend void sync (Probe & p,const Analyzer & a);
        ...
    };
    class Analyzer
    {
        friend void sync (Analyzer & a,const Probe & p) ;
        friend void sync (Probe & p,const Analyzer & a);
    }
    inline void sync (Analyzer & a,const Probe & p)
    {
        ...
    }
    inline void sync (Probe & p,const Analyzer & a)
    {
        ...
    }
    展开全文
  • 实例讲解C++友元,利用实例讲解C++友元的知识

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,927
精华内容 3,170
关键字:

c++友元

c++ 订阅