精华内容
下载资源
问答
  • C++友元函数访问私有成员

    千次阅读 2016-04-11 17:10:48
    #includeusing namespace std;class CTimeInfo{public:void setTime();//默认函数构造void setTime(int newH,int newM)//带参数的成员函数构造{hour=newH;minute=newM;}void showTime(){cout;}private:int
    #include<iostream>
    using namespace std;
    class CTimeInfo
    {
    public:
    void setTime();//默认函数构造
    void setTime(int newH,int newM)//带参数的成员函数构造
    {
    hour=newH;
    minute=newM;
    }
    void showTime()
    {
    cout<<hour<<":"<<minute<<endl;
    }
    private:
    int hour,minute;
    friend void showtime12(CTimeInfo);//友元函数定义,括号里加上类名称
    friend void showtime24(CTimeInfo);//友元函数定义,括号里加上类名称
    };
    void CTimeInfo::setTime()//默认函数在类外初始化
    {
    hour=0;
    minute=0;
    }
    void showtime12(CTimeInfo x)//友元函数实现,注意括号里的格式,以及函数体引用私有成员的格式
    {
    cout<<(x.hour)%12<<":"<<x.minute<<endl;
    }
    void showtime24(CTimeInfo x)
    {
    cout<<x.hour<<":"<<x.minute<<endl;
    }
    int main()
    {
    CTimeInfo t1,t2;
    t1.setTime();
    t1.showTime();
    showtime12(t1);
    showtime24(t1);
    t2.setTime(15,20);
    showtime12(t2);
    showtime24(t2);
    return 0;
    }


    展开全文
  • //这里出错,说name是私有成员无法访问,可我定义的是友元函数啊 return is; } istream & getline (istream & is, Student & stu) { getline(is, stu.name); return is; } 这是为什么...
  • 运算符的时候,一直在String2::CINLIM地方报错,说不能访问私有成员,但是友元函数不是可以访问私有成员吗?我一开始以为是常量静态数据的问题,又试了下用枚举代替static const结果还是不对。。。。。。这个地方卡...
  • C++类成员的三种访问权限:public:可以被该类中的函数、子类的函数、友元函数访问,也可以由该类的对象访问;protected:可以被该类中的函数、子类的函数、友元函数访问,但不可以由该类的对象访问;private:可以...

    C++使用类对数据进行隐藏和封装,类的数据成员一般定义为私有成员,而将提供类与外界通讯接口的成员函数定义为公有的。

    C++类成员的三种访问权限:

    • public:可以被该类中的函数、子类的函数、友元函数访问,也可以由该类的对象访问;
    • protected:可以被该类中的函数、子类的函数、友元函数访问,但不可以由该类的对象访问;
    • private:可以被该类中的函数、友元函数访问,但不可以由子类的函数、该类的对象、访问。

    但是,有时需要定义一些函数,这些函数不是类的一部分,但又需要频繁访问类的私有(private)成员和保护(protected)成员,这时可以将这些函数定义为友元函数。

    除了友元函数,还有友元类,两者统称为友元(friend)。

    借助友元,可以使得普通函数或其他类中的成员函数可以访问某个类的私有成员和保护成员。

    • 友元函数:普通函数可以访问某个类私有成员或保护成员。
    • 友元类:类A中的成员函数可以访问类B中的私有或保护成员。

    1、友元函数

    友元函数时可以直接访问类的私有成员或保护成员,它是定义在类外的普通函数,它不属于任何类,但需要在类的定义中加以声明。

    友元函数的声明格式如下:

    friend 类型 函数名(形参);
    

    示例如下,友元函数 ShowAge() :

    538cc25dc2da68670c9703db2b982fcf.png

    如上图所示,类的友元函数 ShowAge() 定义在类的外部,需要注意的是,尽管 ShowAge() 在类的定义中出现过,但其并不是类的成员函数。

    倘若没有在 Student 类中声明友元函数 ShowAge() ,则其是不能直接访问类的私有成员的,如下图所示。

    02e30edcf7f324517094247fc3c2a787.png

    类的友元函数函数减少了类型检查和安全性检查,提高了程序的运行效率,但它破坏了类的封装性和隐藏性,使得非成员函数也可以访问类的私有成员。

    2、友元类

    友元可以是一个函数,也可以是一个类,该类被称为友元类。

    友元类的所有成员函数都是另一个类的友元函数,都可以访问另一个类中的保护成员和私有成员。

    声明友元类的格式如下:

    friend class 类名;
    

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

    示例如下,类CB是类CA的友元类,可以直接访问类CA的私有成员。

    9f02155b7aec394197c2c4df99ab522a.png

    倘若没有在类CA中声明友元类CB,则CB是不能直接访问CA的私有成员的。

    eb270e03d5f646766cfc15c2fafc2062.png

    使用友元类时,需要注意:

    • 友元关系不能被继承;
    • 友元关系是单向的,不具有交换性。即类B是类A的友元,则类A不一定是类B的友元,需要看类中是否有相应的声明;
    • 友元关系不具有传递性。即类B是类A的友元,类C是类B的友元,但类C不一定是类A的友元,需要看类中是否有相应的声明。

    另外,使用一般不建议把整个类声明为友元类,而只将某些成员函数声明为友元函数,这样更安全些。

    3、友元的优缺点

    利用 friend 修饰符,可以让一些普通函数 或 另一个类的成员函数 直接对某个类的保护成员和私有成员进行操作,提高了程序的运行效率;同时避免把类的成员都声明为public,最大限度地保护数据成员的安全。

    但是,即使是最大限度地保护数据成员,友元也破坏了类的封装性。

    如果将类的封装比喻成一堵墙的话,那么友元机制就像墙上开了一个门。所以使用友元时一定要慎重。

    展开全文
  • 在一个类中,可以利用关键字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 &形参,之后按照友元函数操作一样,可以直接就实现了友元类的操作。 

    展开全文
  •  一个类的私有数据成员通常只能由类的函数成员访问,而友元函数可以访问类的私有数据成员,也能访问其保护成员 2. 友元函数的用处体现在哪里?  2.1 使用友元函数可提高性能,如:用友元函数重载操作符和生成...

    友元函数(friend function)
    1. 什么是友元函数?
        一个类的私有数据成员通常只能由类的函数成员来访问,而友元函数可以访问类的私有数据成员,也能访问其保护成员
    2. 友元函数的用处体现在哪里?
        2.1 使用友元函数可提高性能,如:用友元函数重载操作符和生成迭代器类
        2.2 用友元函数可以访问两个或多个类的私有数据,较其它方法使人们更容易理解程序的逻辑关系
    3. 使用友元函数前应注意:
        3.1 类的友元函数在类作用域之外定义,但可以访问类的私有和保护成员
        3.2 尽管类定义中有友元函数原型,友元函数仍然不是成员函数
        3.3 由于友元函数不是任何类的成员函数,所以不能用句柄(对象)加点操作符来调用
        3.4 public, private, protected成员访问符与友员关系的声明无关,因此友元关系声明可在类定义的任何位置,习惯上在类定义的开始位置
        3.5 友元关系是指定的,不是获取的,如果让类B成为类A的友元类,类A必须显式声明类B为自己的友元类
        3.6 友元关系不满足对称性和传递性
        3.7 如果一个友元函数想与两个或更多类成为友元关系,在每个类中都必须声明为友元函数
    4. 注:由于C++属于混合语言,常在同一个程序中采用两种函数调用且这两种函数调用往往是相反的。类C语言的调用将  
        基本数据或对象传递给函数,C++调用则是将函数(或信息)传递给对象

    实例1. 友元函数的声明、定义与使用

    #include <iostream>
    using namespace std;

    class Car
    {
        friend 
    void display(Car); //类"Car"的朋友display() //友元函数的声明
    private:
        
    int speed;
        
    char color[20];
    public:
        
    void input( )
        
    {
            cout
    <<"Enter the color : ";
            cin
    >>color;
            cout
    <<"Enter the speed : ";
            cin
    >>speed;
        }

    }
    ;

    void display(Car x) //友元函数的定义
    {
        cout
    <<"The color of the car is : "<<x.color<<endl;
        cout
    <<"The speed of the car is : "<<x.speed<<endl;
    }


    int main( )
    {
        Car mine;
        mine.input( ); 
    //访问成员函数
        display(mine); //友元函数的使用 //将对象"mine"传给友元函数
        return 0;
    }


    输出结果:
    Enter the color: green 回车
    Enter the speed: 100 回车
    The color of the car is : green
    The speed of the car is : 100

    实例2. 将一个函数声明为多个类的友元

    #include <iostream>
    using namespace std;

    class Virus; //类'Virus'未定义前要用到,需事先告诉编译器'Virus'是一个类

    class Bacteria
    {
    private:
        
    int life;
    public:
        Bacteria() 
    { life=1; }
    friend 
    void Check(Bacteria, Virus); //类'Bacteria'中,将Check声明为友元函数
    }
    ;

    class Virus
    {
    private:
        
    int life;
    public:
        Virus() : life(
    0{}
    friend 
    void Check(Bacteria, Virus); //类'Virus'中,将Check声明为友元函数
    }
    ;

    void Check (Bacteria b, Virus v) //友元函数的定义
    {
        
    if (b.life==1 || v.life==1)
        
    {
            cout
    <<"/nSomething is alive.";
        }

        
    if (b.life==1)
        
    {
            cout
    <<"/nA bacteria is alive.";
        }

        
    if (v.life==1)
        
    {
            cout
    <<"/nA virus is alive.";
        }

    }


    int main()
    {
        Bacteria fever;
        Virus cholera;
        Check(fever, cholera); //友元函数的调用
        
    return 0;
    }
     


    输出结果:
    Something is alive.
    A bacteria is alive.

    友元类(friend class)
    1. 友元类可以访问与之为友元关系的类的所有私有成员
    2. 友元类使用较少

    实例: 友元类

    #include <iostream>
    using namespace std;

    class Add
    {
    private:
        
    int x,y;
    public:
        Add()
        
    {
            x
    =y=4;
        }

    friend 
    class Support; //类'Support'现在是类'Add'的朋友
    }
    ;

    class Support
    {
    public:
        
    void Sum(Add ob)//此函数可访问类'Add'的所有私有成员
        {
            cout
    <<"The sum of the 2 members is : "<<(ob.x+ob.y)<<endl;
        }

    }
    ;


    int main()
    {
        Add ad;
        Support sup;
        sup.Sum(ad);
        
    return 0;
    }
    展开全文
  • 在程序中经常需要访问对象中的成员访问对象中的成员可以有以下几种方法:通过对象名和成员...成员名不仅可以在类外引用对象的公用数据成员,而且还可以调用对象的公用成员函数,但同样必须指出对象名,如:stu...
  • 类有一个特点就是数据封装数据隐藏,也就是该类的私有成员以及保护成员只有通过它的成员才能访问。通过中的友元机制则解决了这一问题。友元既可以是独立的一个非成员函数,也可以是其他类中的成员函数,还可以一个...
  •  一个类的私有数据成员通常只能由类的函数成员访问,而友元函数可以访问类的私有数据成员,也能访问其保护成员 2. 友元函数的用处体现在哪里?  2.1 使用友元函数可提高性能,如:用友元函数重载操作符和生成迭代...
  •  一个类的私有数据成员通常只能由类的函数成员访问,而友元函数可以访问类的私有数据成员,也能访问其保护成员 2. 友元函数的用处体现在哪里?  2.1 使用友元函数可提高性能,如:用友元函数重载操作符和生成...
  • C++友元函数地球上一种很神奇的生物——女人,说起。众所周知,女生不愿意让别人知道的两个秘密,一个是年龄,另一个就是体重了(为什么女生不愿意让别人知道她们的年龄和体重,这很重要吗?)。现在,我们根据这个...
  • C++友元函数访问类的私有成员

    千次阅读 2017-09-14 15:23:59
    工程中我们经常需要访问一些类的成员,添加一个友元函数可以达到我们的目的。#include #include using namespace std ;class Student{ private: string name; int age; int sore; public: Student(string name,
  • 问题是在看C++primer plus 私有继承部分出现的,按照书上的代码,在VS2015中发现编译不通过,提示为无法访问类的私有成员,该错误是在重载>>运算符时出现的,而其他友元函数访问私有成员未出现错误。 解决方法:将>...
  • 现在要用友元函数求它俩大于1的最小公因数;class FriFunClass { int a, b; public: FriFunClass(int i, int j) { a=i; b=j; } friend int FriFun(FriFunClass x); // 友元函数 }; 这个类的数据信息a,b,...
  • 3.8 友元:友元函数和友元类 ...友元函数不是当前类的成员函数,而是独立于类的外部函数,但它可以访问该类所有的成员,包括私有成员、保护成员和公有成员。在类中声明友元函数时,需在其函数名前加上关键...
  • 为什么80%的码农都做不了架构师?>>> ...
  • 有些情况下,全局函数需要访问类中的私有成员,这种函数叫友元函数;如:客人可以访问客厅,但一般客人不可以去主人卧室,关系较好的朋友才能访问私有的卧室,这时就要用到友元,友元的关键字为friend 示例 #include...
  • 友元函数是可以访问类的私有成员的非成员函数. 也就是定义在类外面的普通函数,不属于类,但是确实类的亲密朋友。 2、友元类 声明为友元类,则A的私有成员在B的所有方法里都可以被访问。 3、...
  • 类的封装就是要将数据成员以及对数据的操作方法kunban
  • 友元 一般来说,类的公有成员能够在类外访问,私有的成员只能被类的其他成员函数...C++提供一种允许外部类和函数存取类的私有成员和保护成员的辅助方法,即将它们声明为一个给定类的友元(或友元函数),使其具有类成

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,229
精华内容 891
关键字:

友元函数访问私有成员