精华内容
下载资源
问答
  • 借助友元(friend),可以使得其他类中的成员函数以及全局范围内的函数访问当前类的 private 成员。friend 的意思是朋友,或者说是好友,与好友的关系显然要比一般人亲密一些。我们会对好朋友敞开心扉,倾诉自己的...

    在C++中,一个类中可以有 public、protected、private 三种属性的成员,通过对象可以访问 public 成员,只有本类中的函数可以访问本类的 private 成员。现在,我们来介绍一种例外情况——友元(friend)。借助友元(friend),可以使得其他类中的成员函数以及全局范围内的函数访问当前类的 private 成员。

    friend 的意思是朋友,或者说是好友,与好友的关系显然要比一般人亲密一些。我们会对好朋友敞开心扉,倾诉自己的秘密,而对一般人会谨言慎行,潜意识里就自我保护。在 C++ 中,这种友好关系可以用 friend 关键字指明,中文多译为“友元”,借助友元可以访问与其有好友关系的类中的私有成员。如果你对“友元”这个名词不习惯,可以按原文 friend 理解为朋友。

    友元函数

    在当前类以外定义的、不属于当前类的函数也可以在类中声明,但要在前面加 friend 关键字,这样就构成了友元函数。友元函数可以是不属于任何类的非成员函数,也可以是其他类的成员函数。

    友元函数可以访问当前类中的所有成员,包括 public、protected、private 属性的。

    1) 将非成员函数声明为友元函数。

    请大家直接看下面的例子:

    #include <iostream>
    using namespace std;
    
    class Student{
    public:
        Student(char *name, int age, float score);
    public:
        friend void show(Student *pstu);  //将show()声明为友元函数
    private:
        char *m_name;
        int m_age;
        float m_score;
    };
    
    Student::Student(char *name, int age, float score): m_name(name), m_age(age), m_score(score){ }
    
    //非成员函数
    void show(Student *pstu){
        cout<<pstu->m_name<<"的年龄是 "<<pstu->m_age<<",成绩是 "<<pstu->m_score<<endl;
    }
    
    int main(){
        Student stu("小明", 15, 90.6);
        show(&stu);  //调用友元函数
        Student *pstu = new Student("李磊", 16, 80.5);
        show(pstu);  //调用友元函数
    
        return 0;
    }
    
    //运行结果:
    //小明的年龄是 15,成绩是 90.6
    //李磊的年龄是 16,成绩是 80.5

    show() 是一个全局范围内的非成员函数,它不属于任何类,它的作用是输出学生的信息。m_name、m_age、m_score 是 Student 类的 private 成员,原则上不能通过对象访问,但在 show() 函数中又必须使用这些 private 成员,所以将 show() 声明为 Student 类的友元函数。


    注意,友元函数不同于类的成员函数,在友元函数中不能直接访问类的成员,必须要借助对象。下面的写法是错误的:

    void show()
    {
        cout<<m_name<<"的年龄是 "<<m_age<<",成绩是 "<<m_score<<endl;
    }
    
    
    
    
    
    成员函数在调用时会隐式地增加 this 指针,指向调用它的对象,从而使用该对象的成员;而 show() 是非成员函数,没有 this 指针,编译器不知道使用哪个对象的成员,要想明确这一点,就必须通过参数传递对象(可以直接传递对象,也可以传递对象指针或对象引用),并在访问成员时指明对象。
    

    2) 将其他类的成员函数声明为友元函数

    friend 函数不仅可以是全局函数(非成员函数),还可以是另外一个类的成员函数。请看下面的例子:

    #include <iostream>
    using namespace std;
    
    class Address;  //提前声明Address类
    
    //声明Student类
    class Student{
    public:
        Student(char *name, int age, float score);
    public:
        void show(Address *addr);
    private:
        char *m_name;
        int m_age;
        float m_score;
    };
    
    //声明Address类
    class Address{
    private:
        char *m_province;  //省份
        char *m_city;  //城市
        char *m_district;  //区(市区)
    public:
        Address(char *province, char *city, char *district);
        //将Student类中的成员函数show()声明为友元函数
        friend void Student::show(Address *addr);
    };
    
    //实现Student类
    Student::Student(char *name, int age, float score): m_name(name), m_age(age), m_score(score){ }
    void Student::show(Address *addr){
        cout<<m_name<<"的年龄是 "<<m_age<<",成绩是 "<<m_score<<endl;
        cout<<"家庭住址:"<<addr->m_province<<"省"<<addr->m_city<<"市"<<addr->m_district<<"区"<<endl;
    }
    
    //实现Address类
    Address::Address(char *province, char *city, char *district){
        m_province = province;
        m_city = city;
        m_district = district;
    }
    
    int main(){
        Student stu("小明", 16, 95.5f);
        Address addr("陕西", "西安", "雁塔");
        stu.show(&addr);
       
        Student *pstu = new Student("李磊", 16, 80.5);
        Address *paddr = new Address("河北", "衡水", "桃城");
        pstu -> show(paddr);
    
        return 0;
    }
    
    //运行结果:
    //小明的年龄是 16,成绩是 95.5
    //家庭住址:陕西省西安市雁塔区
    //李磊的年龄是 16,成绩是 80.5
    //家庭住址:河北省衡水市桃城区


    本例定义了两个类 Student 和 Address,程序第 27 行将 Student 类的成员函数 show() 声明为 Address 类的友元函数,由此,show() 就可以访问 Address 类的 private 成员变量了。

    几点注意:
    ① 程序第 对Address 类进行了提前声明,是因为在 Address 类定义之前、在 Student 类中使用到了它,如果不提前声明,编译器会报错,提示'Address' has not been declared类的提前声明和函数的提前声明是一个道理。

    ② 程序将 Student 类的声明和实现分开了,而将 Address 类的声明放在了中间,这是因为编译器从上到下编译代码,show() 函数体中用到了 Address 的成员 province、city、district,如果提前不知道 Address 的具体声明内容,就不能确定 Address 是否拥有该成员(类的声明中指明了类有哪些成员)。

    ③ 一个函数可以被多个类声明为友元函数,这样就可以访问多个类中的 private 成员。

     

    友元类

    不仅可以将一个函数声明为一个类的“朋友”,还可以将整个类声明为另一个类的“朋友”,这就是友元类。友元类中的所有成员函数都是另外一个类的友元函数。

    例如将类 B 声明为类 A 的友元类,那么类 B 中的所有成员函数都是类 A 的友元函数,可以访问类 A 的所有成员,包括 public、protected、private 属性的。

    更改上例的代码,将 Student 类声明为 Address 类的友元类:

    #include <iostream>
    using namespace std;
    
    class Address;  //提前声明Address类
    
    //声明Student类
    class Student{
    public:
        Student(char *name, int age, float score);
    public:
        void show(Address *addr);
    private:
        char *m_name;
        int m_age;
        float m_score;
    };
    
    //声明Address类
    class Address{
    public:
        Address(char *province, char *city, char *district);
    public:
        //将Student类声明为Address类的友元类
        friend class Student;
    private:
        char *m_province;  //省份
        char *m_city;  //城市
        char *m_district;  //区(市区)
    };
    
    //实现Student类
    Student::Student(char *name, int age, float score): m_name(name), m_age(age), m_score(score){ }
    void Student::show(Address *addr){
        cout<<m_name<<"的年龄是 "<<m_age<<",成绩是 "<<m_score<<endl;
        cout<<"家庭住址:"<<addr->m_province<<"省"<<addr->m_city<<"市"<<addr->m_district<<"区"<<endl;
    }
    
    //实现Address类
    Address::Address(char *province, char *city, char *district){
        m_province = province;
        m_city = city;
        m_district = district;
    }
    
    int main(){
        Student stu("小明", 16, 95.5f);
        Address addr("陕西", "西安", "雁塔");
        stu.show(&addr);
       
        Student *pstu = new Student("李磊", 16, 80.5);
        Address *paddr = new Address("河北", "衡水", "桃城");
        pstu -> show(paddr);
    
        return 0;
    }

    将 Student 类声明为 Address 类的友元类,声明语句为:

    friend class Student;

    有的编译器也可以不写 class 关键字,不过为了增强兼容性还是建议写上。

    关于友元,有两点需要说明:

    • 友元的关系是单向的而不是双向的。如果声明了类 B 是类 A 的友元类,不等于类 A 是类 B 的友元类,类 A 中的成员函数不能访问类 B 中的 private 成员。
    • 友元的关系不能传递。如果类 B 是类 A 的友元类,类 C 是类 B 的友元类,不等于类 C 是类 A 的友元类。

    除非有必要,一般不建议把整个类声明为友元类,而只将某些成员函数声明为友元函数,这样更安全一些。

    展开全文
  •  1、友元函数允许在类外访问该类中的任何成员,使用关键字friend说明。通过友元一个普通函数或类的成员函数可以访问封装于另一个类中的数据。从一定程度上讲,友元是对数据隐藏和封装的破坏,但是为了数据共享和...

    一、友元函数

      1、友元函数允许在类外访问该类中的任何成员,使用关键字friend说明。通过友元一个普通函数或类的成员函数可以访问封装于另一个类中的数据。从一定程度上讲,友元是对数据隐藏和封装的破坏,但是为了数据共享和提高程序的效率与可读性,小的破坏是必要的。

        友元函数不属于该类的成员函数,它是定义在类外的普通函数,只是在类中通过friend关键字声明,从而使该函数可以访问类中的private与protected成员

      2.友元函数的声明一般形式:

    • friend <返回值类型>  <函数名>  (<参数列表>)

      3.使用友元函数注意的要点

    • 1---类中通过使用关键字friend来说明友元函数,但该函数并不是类的成员函数,其声明可以放在类的私有部分也可以放在类的公有部分。友元函数的定义在类体外实现,不需要加类限定。
    • 2---一个类的成员函数可以是另一个类的友元函数,而且一个函数可以是多个类的友元函数。
    • 3---友元函数可以访问类的私有成员和数据,但是可以访问但不能直接使用数据成员需要通过对对象进行引用使用数据成员
    • 4---友元函数在调用上同一般函数一样,不必通过对对象进行引用

    对于1、2、4、的使用解释详见下面代码:

    • class persion{
      public:
            persion(char *pn);
              //友元函数;
            friend void setweigth(persion &p,int h);//注意,参数列表中一般会有一个引用类型的形参,原因参考上面的使用要点3和4;
            void disp(); //类成员函数
      private:
            char name[20];
            int weigth,age;      
      };
      
      persion::persion(char *pn)   //构造函数
      {
         strcpy(name,pn);
         weigth=0;
      }
      void persion::disp()
      {
      cout<<name<<"--"<<weigth<<endl;
      }
      //友元函数的具体实现:这里没有类限定例如 (perion::setweigth)这种形式,这里可以与上面的disp()做个对比,一个属于类的成员,有限定,一个不属于类的成员函数,没有加限定。
      void setweigth(persion &pn,int w)
      {
      pn.weigth=w;       //私有成员数据赋值
      }
      void  main()
      {
        persion p("zhansan");
        setweigth(p,60);//调用实现setweigth(),与一般函数调用一致。
        p.disp();  //调用类的成员函数。
      }

      对于第2点的使用详见下边的代码:一个类的成员函数可以是另一个类的友元函数

    •  1 class wheel;
       2 class car{
       3 public:
       4     car(char *pn);
       5     void run(wheel &w);    //成员函数,做成wheel类中友元函数实现
       6 private:
       7     char name[20];
       8 
       9 };
      10 car::car(char *pn)
      11 {
      12 strcpy(name,pn);
      13 }
      14 
      15 class wheel{
      16 public:
      17     wheel(int s);
      18     friend void car::run(wheel &w);   //这里把car类的成员函数做了友元函数。
      19 private:
      20     int speed;
      21 };
      22 wheel::wheel(int s)
      23 {
      24   speed=s;
      25 }
      26 
      27 void car::run(wheel &w)   //car类成员函数的实现
      28 {
      29     cout<<"the car is running"<<endl;
      30     cout<<"name: "<<name<<" speed :"<<w.speed<<endl;
      31 }
      32 
      33 int  main(int argc, char const *argv[])
      34 {
      35     wheel w(60);
      36     car c("New car");
      37     c.run(w);   //通过car的成员函数作为友元函数访问类wheel类中的数据成员
      38     return 0;
      39 }

    • 使用友元函数计算两点之间的距离:代码示例如下
      •  1 #include <iostream>
         2 #include <cmath>
         3 using namespace std;
         4 //使用友元函数计算两点之间的距离
         5 class Point{
         6 public:
         7     Point(int xx = 0, int yy = 0) { X = xx; Y = yy;}
         8     int GetX() {return X;}
         9     int GetY() {return Y;}
        10     friend float fDist( Point &a, Point &b );
        11 private:
        12     int X, Y;
        13 };
        14  
        15 float fDist(Point &p1, Point &p2){
        16     double x = double(p1.X - p2.X);//通过对象访问私有数据成员,而不是必须使用Getx()函数
        17     double y = double(p1.Y - p2.Y);
        18     return float(sqrt(x*x + y*y));
        19 }
        20 int main(){
        21     Point p1(1, 1), p2(4, 5);
        22     cout << "the distance is:";
        23     cout << fDist(p1, p2) << endl;//计算两点之间的距离
        24     return 0;
        25 }

         友元函数直接使用了对象名访问了私有数据成员X,Y,而不是通过类的成员函数Getx(),Gety(),函数。




     

    二、友元类

      1、和友元函数一样,一个类也可以声明为另一个类的友元类。声明为友元的类可以访问该类的私有数据成员,该类的成员函数都是该友元类的成员函数

    • 友元类的应用详见下边代码:
    •  1 class A{
       2 public:
       3     int GetX() { return x; }
       4     friend class B;//B类是A类的友元类
       5     //其它成员略
       6 private:
       7     int x;
       8 };
       9 class B{
      10 public:
      11     void set(int i);
      12     //其他成员略
      13 private:
      14     A a;
      15 };
      16 void B :: set(int i){
      17     a.x = i;//由于B类是A类的友元类,所以在B的成员函数中可以访问A类对象的私有成员
      18 }

       

       

     

    转载于:https://www.cnblogs.com/southcyy/p/10260092.html

    展开全文
  • 二、友元函数友元函数在类作用域外定义,但它需要在类体中进行说明为了与该类的成员函数加以区别,定义的方式是在类中用关键字friend说明该函数,格式如下: friend 类型 友元函数名(参数表);友元的作用在于提高...
  • 如果声明以前未声明的友元函数,则该函数将被导出到封闭非类范围。 友元声明中声明的函数被视为已使用 extern 关键字声明。(有关 extern 的详细信息,请参阅静态存储类说明符。) 尽管具有全局范围的函数可以在其...
  • 友元函数的说明如下:friend 数据类型函数名(参数)其中,friend是说明友元函数关键字,友元声明可以出现在类中的任何地方。通常,将友元声明成组地放在类定义的开始或结尾是个好主意。归纳起来,友元函数是一种...

    af418581e80ee46ab8edbe9e564d37f7.png

    一、友元函数

    友元函数是一种特殊的函数,它需要在类体内进行说明,可以访问类的私有成员和保护成员,但又不是类的成员函数。友元函数的说明如下:

    friend 数据类型函数名(参数)

    其中,friend是说明友元函数的关键字,友元声明可以出现在类中的任何地方。通常,将友元声明成组地放在类定义的开始或结尾是个好主意。归纳起来,友元函数是一种能够访问类中私有成员的非类成员函数,友元函数在定义上和调用上与普通函数一样。友元的作用在于提高程序的运行效率,但是,它破坏了类的封装性和隐藏性,使得非成员函数可以访问类的私有成员。因此,只有在十分需要的时候才使用友元函数。 例如:分析下面程序的输出结果

    #include

    #include

    using namespace std;

    class TPoint

    {

    private:

    double x,y; //私有数据成员

    public:

    TPoint(double a,double b) //构造函数

    {

    x=a,y=b;

    cout<

    }

    friend double distanceoftwopoints(TPoint &a, TPoint &b) //友元函数

    {

    return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));

    }

    } ;

    int main()

    {

    TPoint p1(2,2),p2(5,5);

    cout<

    return 0;

    }

    上述程序中,distaceoftwopoints()是类TPoint的友元函数,在其中可以直接使用a.x等,由于x等是类TPoint的私有成员,所以在普通函数中是不能这么使用的,但是在友元函数中则可以。下面是该程序的输出。

    9eb52dbc6d53aaa00fbc7ec25e70b006.gif

    友元函数的一个重要特点是它可以是多个类的友元。例如,编写一个程序,求一个点到直线的距离。设计一个点类Point,它有两个私有数据成员x和y,表示点的坐标。另一个类为直线类Line,它有三个私有数据成员a,b和c,表示直线方程ax+by+c=0。这两个类中都说明了一个友元函数dist,用于计算一个点到直线的距离。点(x,y)到直线ax+by+c=0的距离d的计算公式如为:d=abs((ax+by+c)/sqrt(a* a+b*b)),其中abs是求绝对值函数,sqrt是求平方根函数。代码如下:

    #include

    #include

    using namespace std;

    class Line;//提前说明

    class Point

    {

    int x,y;

    public:

    Point(int x1,int y1)

    {

    x=x1; y=y1;

    }

    friend double dist(Line l, Point p);//友元函数说明

    } ;

    class Line

    {

    int a,b,c;

    public:

    Line(int a1, int b1, int c1)

    {

    a=a1; b=b1; c=c1;

    }

    friend double dist(Line l, Point p);//友元函数说明

    };

    double dist(Line l, Point p)//注意:类内已经说明,因此函数前不要加friend

    {

    double d;

    d = abs(l.a*p.x+l.b*p.y+l.c)/(sqrt(l.a*l.a+l.b*l.b));

    return d;

    }

    int main()

    {

    Point p(10,10);

    Line l(2,4,-3);

    cout<

    return 0;

    }

    下面是该程序的输出结果:上述程序中有两个类Point和Line,它们都说明了同一个友元函数:friend double dist(Line l, Point p)。由于在Point类中说明时尚未定义类Line,所以需要在前面用class Line语句进行提前说明。该程序的执行如下:

    7726b4b19e263c1a9b9b5b9a1a301c63.gif

    一个类A的成员 函数f()可以作为另一个类B的友元函数,在这种情况下,必须先定义A类,并且在B类中说明友元函数f()时,要加上成员函数所在类的类名,即:

    class A

    {

    ...

    数据类型 f(参数表)

    ...

    }

    class B

    {

    ...

    friend 数据类型 A::f(参数表);

    ...

    }

    数据类型 A::f(参数表)

    {

    函数体;

    }二、友元类

    除了前面所讲过的友元函数外,友元还可以是一个类,即一个类可以作为另一个类的友元。当一个类作为另外一个类的友元时,就意味着这个类的所有成员函数都是另一个类的友元函数。例如,以下程序说明类B是类A的友元类:

    class A

    {

    ...

    Public:

    friend class B;//说明B是A的友元类

    ...

    }

    例如,有如下程序

    #include

    #include

    using namespace std;

    class A

    {

    int x;

    public:

    A() {x=5;}

    friend class B;//说明B是A的友元类

    };

    class B

    {

    public:

    void disp1(A tmp){

    tmp.x++;

    cout<

    }

    void disp2(A tmp){

    tmp.x--;

    cout<

    }

    };

    int main()

    {

    A obj1;

    B obj2;

    obj2.disp1(obj1);

    obj2.disp2(obj1);

    return 0;

    }

    }

    上述程序中,类B是类A的友元类,类B包括两个成员函数,这两个成员函数可以当成类A自己的友元函数一样使用,该程序执行结果如下:

    788942a6c8886aec9b819f8790eb4d9b.gif

    友元类的所有成员函数都是另一个类的友元函数,都可以访问另一个类中的隐藏信息(包括私有成员和保护成员)。当希望一个类可以存取另一个类的私有成员时,可以将该类声明为另一类的友元类。关于友元类的注意事项:(1)友元关系不能被继承。(2)友元关系是单向的,不具有交换性。若类B是类A的友元,类A不一定是类B的友元,要看在类中是否有相应的声明。(3)友元关系不具有传递性。若类B是类A的友元,类C是B的友元,类C不一定是类A的友元,同样要看类中是否有相应的申明。

    三、习题解析

    1.一个类的友元函数能够访问该类的( )。A.私有成员 B.保护成员 C.公有成员 D.所有成员

    解析:一个类的友元函数对类成员的访问能力等同于类的成员函数,即能访问类的所有成员,选D。

    2.下列的各类函数中,( )不是类的成员函数。A、 构造函数 B、析构函数 C、友元函数 D、拷贝初始化构造函数

    答案:C

    3.下列关于友元的描述中,错误的是( )A.友元函数可以访问该类的私有数据成员B.一个类的友元类中的成员函数都是这个类的友元函数C.类与类之间的友元关系可以继承D.友元可以提高程序的运行效率

    解析:友元关系是不能被继承的,并且是单向的,不可交换的。

    4.下列程序利用友元函数求2个点的距离,找出存在的错误(有2个错)。

    #include

    #include

    class Tpoint

    { double x,y;

    public:

    Tpoint(double a,double b)

    { x=a; y=b; }

    friend double distance(Tpoint &, Tpoint &);

    };

    double Tpoint::distance(Tpoint &p1,Tpoint &p2)

    { double dist;

    dist=sqrt((p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y));

    return dist;

    }

    int main()

    { Tpoint p1(2,2),p2(5,6);

    cout<

    return 0;

    }四、小结

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

    优点:可以灵活地实现需要访问若干类的私有或受保护的成员才能完成的任务;便于与其他不支持类概念的语言(如C语言、汇编等)进行混合编程;通过使用友元函数重载可以更自然地使用C++语言的IO流库,便于实现运算符的重载等功能。

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

    参考书目

    《C++ Primer》,《C++语言习题与解析》等

    展开全文
  • 在一个类中,可以利用关键字friend将其他的函数或类声明为友元,如果友元是一般函数或者类的成员函数,称为友元函数,如果友元是一个类,则成为友元类,友元类的所有成员函数都自动成为友元函数友元函数友元...

    在一个类中,可以利用关键字friend将其他的函数或类声明为友元,如果友元是一般函数或者类的成员函数,称为友元函数,如果友元是一个类,则成为友元类,友元类的所有成员函数都自动成为友元函数。

    友元函数:

    友元函数是在类中用关键字friend修饰的友元函数,友元函数可以是一个普通的函数,也可以是其他类的成员函数。虽然它不是本类的成员函数,但是在它的函数体中可以通过对象名访问类的私有和保护成员。

    友元普通函数:(将普通函数声明为友元函数)

    #include<iostream>
    using namespace std;
    class Time
    {
    public:
    	Time(int, int, int);
    	friend void display(Time &);//普通函数在类中的声明。
    private:
    	int hour;
    	int minute;
    	int second;
    };
    Time::Time(int h,int m,int s)
    {
    	hour = h;
    	minute = m;
    	second = s;
    }
    void display(Time &t)//普通函数在类中声明为友元
    {
    	cout << t.hour << ":" << t.minute << ":" << t.second << endl;
    }
    int main()
    {
    	Time p(13,42,32);
    	display(p);
    	return 0;
    }

    友元成员函数:

    将一个类中的成员函数去作为另一个类的友元成员函数,

    #include<iostream>
    using namespace std;
    class Date;
    class Time
    {
    public:
    	Time(int, int, int);
    	void display(Date &);
    private:
    	int hour;
    	int minute;
    	int second;
    };
    class Date
    {
    public:
    	Date(int, int, int);
    	friend void Time::display(Date &);
    private:
    	int month;
    	int year;
    	int day;
    };
    Time::Time(int h,int m,int s)
    {
    	hour = h;
    	minute = m;
    	second = s;
    }
    Date::Date(int y, int mon, int d)
    {
    	year = y;
    	month = mon;
    	day = d;
    
    }
    void Time::display(Date &t)
    {
    	cout <<t.year<<":"<<t.month<<":"<<t.day<<","<< hour << ":" << minute << ":" << second << endl;
    }
    int main()
    {
    	Time p(13,42,32);
    	Date q(2019, 4, 29); 
    	p.display(q);
    	return 0;
    }

    以上代码的逻辑上是display是Time类中的一个函数,在定义Time类之前声明了Date类,之后在Time类中声明,display函数的参数是Date类的引用,在Date类中进行声明,添加friend关键字,此时需要添加Time类作用符,之后在类外正常定义。目标就是将Time类的成员函数作为Date类的友元函数,就可以通过该友元函数访问Date类的私有成员

    友元类:

    跟友元函数很相似,可以将一个类作为另一个类的友元类,若A类是B类的友元类,则A类的所有成员函数都是B类的友元函数。都可以去访问B类的私有和保护成员,大概形式为:

    class B;
    class A
    {
       friend Class B;  
    }
    #include<iostream>
    using namespace std;
    class Date;
    class Time
    {
    public:
    	Time(int, int, int);
    	void display(Date &);
    private:
    	int hour;
    	int minute;
    	int second;
    };
    class Date
    {
    public:
    	Date(int, int, int);
    private:
    	int month;
    	int year;
    	int day;
    	friend class Time;
    };
    Time::Time(int h,int m,int s)
    {
    	hour = h;
    	minute = m;
    	second = s;
    }
    Date::Date(int y, int mon, int d)
    {
    	year = y;
    	month = mon;
    	day = d;
    
    }
    void Time::display(Date &t)
    {
    	cout << t.year << ":" << t.month << ":" << t.day << "," << hour << ":" << minute << ":" << second << endl;
    }
    int main()
    {
    	Time p(13,42,32);
    	Date q(2019, 4, 29); 
    	p.display(q);
    	return 0;
    }

    先声明一个Date类,然后自己再去定义一个Time类,之后再具体定义Date类,并自己在类中声明一个友元Time类,不过再Time类中的成员函数display()还需要加上Date &形参,之后按照友元函数操作一样,可以直接就实现了友元类的操作。 

    展开全文
  • 当声明了友元函数或者友元类之后,该函数或者类可以访问类的所有成员,包括private成员,当然访问过程需要通过类的对象进行。例如声明一个友元函数,有两种情况: ①该函数是普通的全局函数 一般情况下,使用一个...
  • C++ 友元函数

    2020-11-20 16:37:25
    1.友元函数的简单介绍 1.1为什么要使用友元函数 在实现类之间数据共享时,减少系统开销,提高效率。如果类A中的函数要访问类B中的成员(例如:智能指针类的实现),那么类A中该函数要是类B的友元函数。 具体来说:...
  • 关键字const 1、加类型前面加 const 2、如果不想改变一个变量的值,也...友元函数 friend 给类交朋友,朋友就可以访问该类的私有成员,这个编译器级别做的事情。 3、同样还有友元类,和友元函数道理是一样的 ...
  • C++之中的友元函数的作用

    万次阅读 多人点赞 2017-12-09 17:23:22
    友元提供了不同类的成员函数之间、类的成员函数与一般函数之间进行数据共享的机制。通过友元,一个不同函数或另一个类中的成员函数可以访问类中的私有成员...友元函数友元函数是可以直接访问类的私有成员的非成员函
  • C++——友元函数&内联函数

    千次阅读 多人点赞 2018-12-07 23:55:15
    友元函数 类的友元函数是定义在类外部,但有权访问类的所有私有(private)成员和保护(protected)成员。尽管友元函数的原型有在类的定义中出现过,但是友元函数并不是成员函数。 友元可以是一个函数,该函数被...
  • C++友元函数的定义和使用 <C++析构函数C++友元类> 类的封装性实现了数据隐藏,即类的私有成员在该类的作用域之外是不可见的。但有时可能需要在类的外部访问类的私有成员,为此 C++ 提供了一种允许类外的函数...
  • 友元函数是一个不属于类成员的函数,但它可以访问该类的私有成员。换句话说,友元函数被视为好像是该类的一个成员。友元函数可以是常规的独立函数,也可以是其他类的成员。实际上,整个类都可以声明为另一个类的友元...
  • 友元函数 友元类 友元成员函数

    千次阅读 2018-05-07 22:34:40
    友元 一般来说,类内的私有数据是对外不可见的,但在有些情况下,我们需要在类外对该类的私有数据进行访问,这就需要用到一种新技术——友元(friend),即在声明前...友元函数是指某些非类成员函数,但可以访问类...
  • 有时候有一个外部函数就是需要访问,为了解决这个问题,c++开了个后门,就是友元函数友元函数就是将外部函数在类中进行申明,声明时前面添加friend关键字,将其声明为类的友元函数后就可以任意访问类中成员。...
  • C++ 之友元函数

    2020-06-25 17:08:42
    友元函数 概念: 类里面可以定义public、protected、private三种属性的成员,通过对象可以访问public成员,只有本类中的函数可以访问本类的private成员。 在C++里有一种特殊机制——友元(friend)。借助友元...
  • 友元函数

    万次阅读 多人点赞 2018-09-03 10:27:37
    引入友元函数的原因 类具有封装、继承、多态、信息隐藏的特性,只有类的成员函数...必须在类的说明中说明友元函数,说明时以关键字friend开头,后跟友元函数的函数原型,友元函数的说明可以出现在类的任何地方,包...
  • 友元函数,内联函数

    2018-10-13 00:25:52
    类的友元函数是定义在类外部,但有权访问类的所有私有(private)成员和保护(protected)成员。尽管友元函数的原型有在类的定义中出现过,但是友元函数并不是成员函数。 友元可以是一个函数,该函数被称为友元函数...
  • 友元函数和重载

    千次阅读 2018-07-11 10:54:42
    友元函数:类的友元函数是定义在类外部,但有权访问类的所有私有(private)成员和保护(protected)成员。尽管友元函数的原型有在类的定义中出现过,但是友元函数并不是成员函数。友元可以是一个函数,该函数被称为...
  • 友元函数示例代码

    2019-05-08 20:28:54
    友元函数 类boy的所有成员函数都类girl的友元函数 关键步骤:首先要在类boy前“前向声明”类girl,然后在girl的私有成员里用“friend”声明类boy是友元类; 示例代码: #include <iostream> using ...
  • 通过class关键字可以定义一个类 class Cow { private: int age; protected: double weight; public: bool isMale; }; 一个类具有public protected 和 private 三种类型的成员。成员可以是变量或者函数。下面给出...
  • 3.11 友元函数和友元类 3.11.1 友元关系介绍 在前面章节讲过,类里面可以定义public、protected、private三种属性的成员,通过对象可以访问public成员,只有本类中的函数可以访问本类的private成员。 在C++里有一种...
  • 什么场景下会用到友元函数

    千次阅读 2017-10-11 07:56:42
    什么场景下会用到友元函数友元函数的作用是什么,友元函数和普通成员函数又有怎样的区别?这都是C++当中的一些基本概念,掌握好了无论是维护项目还是做项目开发都大有裨益。本文主要浅谈一下C++中的友元函数,如有...
  • 关于C++中的friend友元函数的总结

    万次阅读 多人点赞 2018-12-07 10:05:18
    1.友元函数的简单介绍 1.1为什么要使用友元函数 在实现类之间数据共享时,减少系统开销,提高效率。如果类A中的函数要访问类B中的成员(例如:智能指针类的实现),那么类A中该函数要是类B的友元函数。 具体来说:...
  • C++友元函数和友元类用法详解

    万次阅读 多人点赞 2018-01-21 21:12:37
    但是,有时需要定义一些函数,这些函数不是类的一部分,但又需要频繁地访问类的数据成员,这时可以将这些函数定义为该函数的友元函数。除了友元函数外,还有友元类,两者统称为友元。友元的作用是提高了程序的运行...
  • 一、友元函数 二、友元类 三、友元的优缺点 一、友元函数 结合着类的特性,可知:类具有封装和信息隐藏的特性。只有类的成员函数才能访问类的私有成员,程序中的其他函数是无法访问私有成员的。非成员函数可以...
  • 借助友元(friend),可以使得其他类中的成员函数以及全局范围内的函数访问当前类的 private 成员。 friend 的意思是朋友,或者说是好友,与好友的关系显然要比一般人亲密一些。我们会对好朋友敞开心扉,倾诉自己的...
  • operator是关键字,它与重载的运算符一起构成函数名。因函数名的特殊性,C++编译器可以将这类函数识别出来。 2 运算符重载函数的参数 2.1 运算符重载函数为类的成员函数 当用类的成员函数实现运算符的重载时
  • 友元函数friend

    2017-11-05 14:30:43
    学过C++的程序员都知道,一个常规的成员函数声明描述了三件在逻辑上相互不同的事情: 1、该函数能访问类声明的私用部分。...什么是友元函数友元函数友元函数可以直接访问类的私有成员,它是定义在类外部的普

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 16,949
精华内容 6,779
关键字:

友元函数的关键字