友元函数_友元函数访问权限 - CSDN
友元函数 订阅
友元函数是指某些虽然不是类成员却能够访问类的所有成员的函数。类授予它的友元特别的访问权。通常同一个开发者会出于技术和非技术的原因,控制类的友元和成员函数(否则当你想更新你的类时,还要征得其它部分的拥有者的同意)。 展开全文
友元函数是指某些虽然不是类成员却能够访问类的所有成员的函数。类授予它的友元特别的访问权。通常同一个开发者会出于技术和非技术的原因,控制类的友元和成员函数(否则当你想更新你的类时,还要征得其它部分的拥有者的同意)。
信息
外文名
friend
类    型
虚拟函数
中文名
友元函数
学    科
计算机科学
友元函数友元函数
成员函数和非成员函数最大的区别在于成员函数可以是虚拟的而非成员函数不行。所以,如果有个函数必须进行动态绑定(见条款38),就要采用虚拟函数,而虚拟函数必定是某个类的成员函数。关于这一点就这么简单。如果函数不必是虚拟的,情况就稍微复杂一点。()看下面表示有理数的一个类:class rational {public:rational(int numerator = 0,int denominator = 1);int numerator() const;int denominator() const;private:...};这是一个没有一点用处的类。(用条款18的术语来说,接口的确最小,但远不够完整。)所以,要对它增加加,减,乘等算术操作支持,但是,该用成员函数还是非成员函数,或者,非成员的友元函数来实现呢?当拿不定主意的时候,用面向对象的方法来考虑!有理数的乘法是和rational类相联系的,所以,写一个成员函数把这个操作包到类中。class rational {public:...const rational operator*(const rational& rhs) const;};(如果你不明白为什么这个函数以这种方式声明——返回一个const值而取一个const的引用作为它的参数——参考条款21-23。)条款21: 尽可能使用const条款22: 尽量用“传引用”而不用“传值”条款23: 必须返回一个对象时不要试图返回一个引用可以很容易地对有理数进行乘法操作:rational oneeighth(1,8);rational onehalf(1,2);rational result = onehalf * oneeighth; // 运行良好result = result * oneeighth; // 运行良好但不要满足,还要支持混合类型操作,比如,rational要能和int相乘。但当写下下面的代码时,只有一半工作:result = onehalf * 2; // 运行良好result = 2 * onehalf; // 出错!这是一个不好的苗头。记得吗?乘法要满足交换律。如果用下面的等价函数形式重写上面的两个例子,问题的原因就很明显了:result = onehalf.operator*⑵; // 运行良好result = 2.operator*(onehalf); // 出错!对象onehalf是一个包含operator*函数的类的实例,所以编译器调用了那个函数。而整数2没有相应的类,所以没有operator*成员函数。编译器还会去搜索一个可以象下面这样调用的非成员的operator*函数(即,在某个可见的名字空间里的operator*函数或全局的operator*函数):result = operator*(2,onehalf); // 错误!但没有这样一个参数为int和rational的非成员operator*函数,所以搜索失败。再看看那个成功的调用。它的第二参数是整数2,然而rational::operator*期望的参数却是rational对象。怎么回事?为什么2在一个地方可以工作而另一个地方不行?秘密在于隐式类型转换。编译器知道传的值是int而函数需要的是rational,但它也同时知道调用rational的构造函数将int转换成一个合适的rational,所以才有上面成功的调用(见条款m19)。换句话说,编译器处理这个调用时的情形类似下面这样:const rational temp⑵; // 从2产生一个临时// rational对象result = onehalf * temp; // 同onehalf.operator*(temp);当然,只有所涉及的构造函数没有声明为explicit的情况下才会这样,因为explicit构造函数不能用于隐式转换,这正是explicit的含义。如果rational象下面这样定义:class rational {public:explicit rational(int numerator = 0,// 此构造函数为int denominator = 1); // explicit...const rational operator*(const rational& rhs) const;...};那么,下面的语句都不能通过编译:result = onehalf * 2; // 错误!result = 2 * onehalf; // 错误!这不会为混合运算提供支持,但至少两条语句的行为一致了。然而,我们刚才研究的这个类是要设计成可以允许固定类型到rational的隐式转换的——这就是为什么rational的构造函数没有声明为explicit的原因。这样,编译器将执行必要的隐式转换使上面result的第一个赋值语句通过编译。实际上,如果需要的话,编译器会对每个函数的每个参数执行这种隐式类型转换。但它只对函数参数表中列出的参数进行转换,决不会对成员函数所在的对象(即,成员函数中的*this指针所对应的对象)进行转换。这就是为什么这个语句可以工作:result = onehalf.operator*⑵; // converts int -> rational而这个语句不行:result = 2.operator*(onehalf); // 不会转换// int -> rational第一种情形操作的是列在函数声明中的一个参数,而第二种情形不是。尽管如此,你可能还是想支持混合型的算术操作,而实现的方法应该清楚了:使operator*成为一个非成员函数,从而允许编译器对所有的参数执行隐式类型转换:class rational {... // contains no operator*};// 在全局或某一名字空间声明,// 参见条款m20了解为什么要这么做const rational operator*(const rational& lhs,const rational& rhs){return rational(lhs.numerator() * rhs.numerator(),lhs.denominator() * rhs.denominator());}rational onefourth(1,4);rational result;result = onefourth * 2; // 工作良好result = 2 * onefourth; // 万岁,它也工作了!这当然是一个完美的结局,但还有一个担心:operator*应该成为rational类的友元吗?这种情况下,答案是不必要。因为operator*可以完全通过类的公有(public)接口来实现。上面的代码就是这么做的。只要能避免使用友元函数就要避免,因为,和现实生活中差不多,友元(朋友)带来的麻烦往往比它(他/她)对你的帮助多。然而,很多情况下,不是成员的函数从概念上说也可能是类接口的一部分,它们需要访问类的非公有成员的情况也不少。让我们回头再来看看本书那个主要的例子,string类。如果想重载operator>>;和operator<<;来读写string对象,你会很快发现它们不能是成员函数。如果是成员函数的话,调用它们时就必须把string对象放在它们的左边:// 一个不正确地将operator>>;和// operator<<;作为成员函数的类class string {public:string(const char *value);...istream& operator>>(istream& input);ostream& operator<<(ostream& output);private:char *data;};string s;s >> cin; // 合法,但// 有违常规s << cout; // 同上这会把别人弄糊涂。所以这些函数不能是成员函数。注意这种情况和前面的不同。这里的目标是自然的调用语法,前面关心的是隐式类型转换。istream& operator>>(istream& input,string& string){delete [] string.data;read from input into some memory,and make string.datapoint to itreturn input;}ostream& operator<<(ostream& output,const string& string){return output << string.data;}注意上面两个函数都要访问string类的data成员,而这个成员是私有(private)的。但我们已经知道,这个函数一定要是非成员函数。这样,就别无选择了:需要访问非公有成员的非成员函数只能是类的友元函数。假设f是想正确声明的函数,c是和它相关的类:·虚函数必须是成员函数。如果f必须是虚函数,就让它成为c的成员函数。·operator>>;和operator<<;决不能是成员函数。如果f是operator>>;或operator<<;,让f成为非成员函数。如果f还需要访问c的非公有成员,让f成为c的友元函数。·只有非成员函数对最左边的参数进行类型转换。如果f需要对最左边的参数进行类型转换,让f成为非成员函数。如果f还需要访问c的非公有成员,让f成为c的友元函数。·其它情况下都声明为成员函数。如果以上情况都不是,让f成为c的成员函数。
收起全文
精华内容
参与话题
  • c++中友元函数理解与使用

    千次阅读 2018-04-15 18:34:19
    在学习c++这一块,关于友元函数和友元类,感觉还是不好理解,但是井下心来,理解,需要把我一下几点。 首先讲友元函数。(1)友元函数:1)C++中引入友元函数,是为在该类中提供一个对外(除了他自己意外)访问的...

    在学习c++这一块,关于友元函数和友元类,感觉还是不好理解,但是井下心来,理解,需要把我一下几点。 
    首先讲友元函数。

    (1)友元函数:

    1)C++中引入友元函数,是为在该类中提供一个对外(除了他自己意外)访问的窗口;
    2)这个友元函数他不属于该类的成员函数,他是定义在类外的普通函数,只是在类中声明该函数可以直接访问类中的private或者protected成员。
    • 1
    • 2

    使用友元函数声明的一般形式:

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

    使用友元函数注意的要点:

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

    例如如下形式:这里解释上面的1,3,4要点的使用,加以理解。

    #include <iostream>
    #include <cstring>
    using namespace std;
    
    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)
    {
    strcpy(pn.name,pn);//实现字符串复制
    pn.weigth=w;       //私有成员数据赋值
    
    }
    
    void  main()
    {
      persion p("zhansan");
      //调用实现setweigth(),与一般函数调用一致。
      setweigth(p,60);
    
      p.disp();  //调用类的成员函数。
    
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45

    关于要点2的使用,我给出一段代码案例:

    #include <iostream>
    #include <cstring>
    using namespace std;
    
    class wheel;
    class car{
    public:
        car(char *pn);
        void run(wheel &w);    //成员函数,做成wheel类中友元函数实现
    private:
        char name[20];
    
    };
    car::car(char *pn)
    {
    strcpy(name,pn);
    }
    
    class wheel{
    public:
        wheel(int s);
        friend void car::run(wheel &w);   //这里把car类的成员函数做了友元函数。
    private:
        int speed;
    };
    wheel::wheel(int s)
    {
      speed=s;
    }
    int  main(int argc, char const *argv[])
    {
        wheel w(60);
        car c("New car");
        c.run(w);
        return 0;
    }
    
    void car::run(wheel &w)   //car类成员函数的实现
    {
        cout<<"the car is running"<<endl;
        cout<<"name: "<<name<<" speed :"<<w.speed<<endl;
    }
    
    
    
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/qq_26337701/article/details/53996104
    展开全文
  • 友元函数

    2018-08-25 15:00:28
    类的友元函数是定义在类外部,但有权访问此类里面的所有私有成员和保护成员,并且友元函数在类中不属于成员函数。 友元可以是函数,也可以是类,称作友元函数或友元类,友元类的整个类及其所有cyua所有成员都是友元...

    类的友元函数是定义在类外部,但有权访问此类里面的所有私有成员和保护成员,并且友元函数在类中不属于成员函数。

    友元可以是函数,也可以是类,称作友元函数或友元类,友元类的整个类及其所有cyua所有成员都是友元。

    声明函数为一个类的友元,需要在类定义中在该函数前使用关键字friend

    友元函数可直接调用,不需要通过对象或指针。

    友元函数没有this指针(因为友元函数不是类的成员),所以参数有三种情况:

    1、访问非static成员时需要对象做参数。

    2、访问static成员或全局变量时不需要对象做参数

    3、如果做参数的对象是全局对象,则不需要对象做参数

    展开全文
  • C++ 之友元函数

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

    友元函数

    一、概念

    类里面可以定义public、protected、private三种属性的成员,通过对象可以访问public成员,只有本类中的函数可以访问本类的private成员。

    在C++里有一种特殊机制——友元(friend)。借助友元(friend),可以使得其他类中的成员函数以及全局范围内的函数访问当前类的private(私有)成员。

    friend 的意思是朋友,与朋友的关系显然要比一般人亲密一些。在C++中,这种友好关系可以用 friend 关键字指明,中文多译为“友元”,借助友元可以访问与其有好友关系的类中的私有成员。

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

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


    二、引例

    问题:

    Integer num1(1024),Integer num2(24);
    Integer num3 = num1 + num2;//正常执行
    Integer num4 = 1024 + num1;//编辑错误
    

    Integer Integer::operator+(const Integer & other);
    是作为成员函数重载的,num1.operator+(num2)合法。但是1024.operator+(num1)中,int类型并没有重载+号。

    解决方案:

    friend const Integer operator+(const Integer &, const Integer &)
    friend ostream & operator<<(ostream &, const Integer &);
    
    const Integer operator+(const Integer & leftNum,const Integer right Num){
    	return Integer(leftNum.m_num+rightNum.m_num);
    }
    ostream & operator<<(ostream & out,const Integer & num){
    	out<<num.m_num;
    	return out;
    }
    

    三、具体实例

    1、实现对+(加)、-(减)、*(乘)、/(除)、%(取模)运算符的重载
    2、实现赋值运算符的重载
    3、使用友元方式重载了+(加)号运算符,实现int类型和Integer类型相加
    4、重载流运算符(流运算符一般只能使用友元的方式重载)

    具体实现:
    Integer.h

    #ifndef INTEGER_H
    #define INTEGER_H
    #include<iostream>
    using namespace std;
    
    //自己定义的整型类,将整型封装成类,以实现面向对象的封装
    
    class Integer
    {
        public:
            Integer();
            Integer(int value):m_value(value){}
    
            //重载+号运算符
            const Integer operator+(const Integer other) const;
            //重载-号运算符
            const Integer operator-(const Integer other) const;
            //重载*号运算符
            const Integer operator*(const Integer other) const;
            //重载/号运算符
            const Integer operator/(const Integer other) const;
            //重载%号运算符
            const Integer operator%(const Integer other) const;
    
            //重载赋值符号 不需要const修饰函数
            //num4.operator=(num3);
            const Integer & operator=(const Integer & other);
    
            friend const Integer operator+(int intValue, const Integer & other);
    
            //流运算符一般只能使用友元的方式重载
            //今后就可以直接重载流运算符
            friend ostream & operator<<(ostream & out, const Integer & num);
    
            int IntValue(){return m_value;}
    
            virtual ~Integer();
    
        protected:
    
        private:
            int m_value;        //实际的整型数字(m是member)
    };
    
    #endif // INTEGER_H
    

    Integer.cpp

    #include "Integer.h"
    #include<iostream>
    using namespace std;
    //调用默认构造时,会为私有m_value赋一个默认值为0
    Integer::Integer():m_value(0)
    {
        //ctor
    }
    //重载+号运算符
    const Integer Integer::operator+(const Integer other) const
    {
        Integer result(this->m_value + other.m_value);  //用来返回的结果对象
        return result;
    }
    //重载-号运算符
    const Integer Integer::operator-(const Integer other) const
    {
        Integer result(this->m_value - other.m_value);
        return result;
    }
    //重载*号运算符
    const Integer Integer::operator*(const Integer other) const
    {
        return Integer (this->m_value * other.m_value);
    }
    //重载/号运算符
    const Integer Integer::operator/(const Integer other) const
    {
        return Integer (this->m_value / other.m_value);
    }
    //重载%号运算符
    const Integer Integer::operator%(const Integer other) const
    {
        return Integer (this->m_value % other.m_value);
    }
    //赋值运算符重载
    const Integer & Integer::operator=(const Integer & other)
    {
        //条款11:如果是自我赋值,就不要做任何事情
        if(this == &other)  //正统测试
            return *this;
        this->m_value = other.m_value;
        return *this;
    }
    //友元函数不需要使用域运算符了
    const Integer operator+(int intValue, const Integer & other)
    {
        cout<<"使用友元方式重载了+运算符,实现int类型和Integer类型相加"<<endl;
        return Integer(intValue + other.m_value);
    }
    ostream & operator<<(ostream & out, const Integer & num)
    {
    	out << num.m_value;
    	return out;
    }
    Integer::~Integer()
    {
        //dtor
    }
    

    main.cpp

    #include <iostream>
    #include "Integer.h"
    #include "ConstDemo.h"
    
    using namespace std;
    
    void TestInteger();
    
    int main()
    {
        TestInteger();
       // ConstDemo1();
        return 0;
    }
    
    void TestInteger()
    {
        Integer int1(1024),int2(2048),int3;
        int3 = int1 + int2;
        cout<<"int3 = int1 + int2的结果为:"<<int3.IntValue()<<endl;
        int3 = int1 - int2;
        cout<<"int3 = int1 - int2的结果为:"<<int3.IntValue()<<endl;
        int3 = int1 * int2;
        cout<<"int3 = int1 * int2的结果为:"<<int3.IntValue()<<endl;
        int3 = int1 / int2;
        cout<<"int3 = int1 / int2的结果为:"<<int3.IntValue()<<endl;
        int3 = int1 % int2;
        cout<<"int3 = int1 % int2的结果为:"<<int3.IntValue()<<endl;
    
    
        Integer int4;
        int4 = int3;
        cout<<"int4 = int3的结果为:"<<int4.IntValue()<<endl;
    
        Integer int5;
        int5 = 1024 + int4;
        cout<<"int5 = "<<int5.IntValue()<<endl;
    
        cout << "重载了<<运算符后,可以直接打印对象:int5 = " << int5<<endl;
    
    }
    
    
    //打印结果
    /*
    int3 = int1 + int2的结果为:3072
    int3 = int1 - int2的结果为:-1024
    int3 = int1 * int2的结果为:2097152
    int3 = int1 / int2的结果为:0
    int3 = int1 % int2的结果为:1024
    int4 = int3的结果为:1024
    使用友元方式重载了+运算符,实现int类型和Integer类型相加
    int5 = 2048
    重载了<<运算符后,可以直接打印对象:int5 = 2048
    
    */
    

    补充:

    不知道运算符重载的同学可以查看博客:C++ 之运算符重载


    四 、运算符声明准则

    运算符声明类成员还是声明独立友元函数建议准则:
    1、C++规定,赋值运算符=、数组下标运算符[]、函数调用运算符()、成员访问运算符-> 。在重载时必须声明为类的成员函数
    2、流运算符<<、>>、类型转换运算符不能定义为类的成员函数
    3、一元运算符和符合赋值运算符重载时,一般声明类的成员函数
    4、二元运算符在运算符重载时,一般声明为友元函数

    注:
    1、对于很多运算符来说,可以选择使用成员函数或者非成员函数来实现运算符重载。一般来说,非成员函数应该时友元函数,这样才能直接访问类的私有数据。
    2、在定义运算符时,必须选择其中的一种格式,而不是同时选择这两种格式,同时定义这两种格式将被是为二义性错误,导致编译错误。
    3、那么哪种格式最好呢?对于某些运算符来说,成员函数是唯一合法的解释,在其他情况下,这两种格式没有太大的区别。有时,根据类的设计,使用非成员函数版本可能更好(尤其是为类定义类型转换时)。

    补充:

    C++ 之友元运算符函数与成员运算符函数的不同

    流运算符一般只能使用友元的方式重载

    //今后就可以直接重载流运算符
    friend ostream & operator<<(ostream & out, const Integer & num);
    
    //实现:
    ostream & operator<<(ostream & out, const Integer & num)
    {
    	out << num.m_value;
    	return out;
    }
    
    //main.cpp
    cout << "重载了<<运算符后,可以直接打印对象:int5 = " << int5<<endl;
    

    五、小结

    友元函数
    流运算符<<、>>、类型转换运算符不能定义为类的成员函数,只能是友元函数。
    二元运算符在运算符重载时,一般声明为友元函数。


    展开全文
  • C++的友元函数 为什么要使用友元函数 某种特定的场合,实现某种功能,但是类身的成员函数,因为各种原因无法实现需要借助外援,这个时候就可以使用友元函数友元函数的特点 可以直接访问private:的数据...

    C++的友元函数

    为什么要使用友元函数

    • 某种特定的场合,实现某种功能,但是类自身的成员函数,因为各种原因无法实现需要借助外援,这个时候就可以使用友元函数。

    友元函数的特点

    • 可以直接访问private:的数据成员

    友元函数的两种形式

    • 友元函数,友元类。

    • 友元函数:

    • 使用全局函数作为友元函数

    • 实例

    • Friend.h

    • Friend.cpp

    • main.cpp

    • 输出信息

    • 使用类的成员函数作为友元函数:

    • 实例

    • Friend.h

    • Friend.cpp

    • FrienService.h

    • FrienService.cpp

    • main.cpp

    • 输出信息

    友元类

    友元类的作用:

    • 如果把A类作为B类的友元类,那么A类的所有成员函数,就可以直接访问B类的private成员函数。

    • 友元类可以直接访问对应类的所有成员

    实例

    FrienService.h

    FrienService.cpp

    Friend.h

    Friend.cpp

    main.cpp

     

    输出结果

    • 友元类,友元函数与方问权限无关,可以直接放在private,public,protected任意位置

    • 来自奇牛学院~#残芯-学习笔记分享

    展开全文
  • 友元函数 friend

    千次阅读 2017-07-06 15:49:53
    一、一个类的成员函数有三个互不相干作用 1.可以通过类的成员方法,访问它的私有数据。 2.该函数的作用域在类中。 3.在外部调动该函数必须通过成员访问...2.友元函数可以在类中实现,也可以在类外实现(一般是在类的
  • C++——友元函数&内联函数

    千次阅读 2018-12-07 23:55:15
    友元函数 类的友元函数是定义在类外部,但有权访问类的所有私有(private)成员和保护(protected)成员。尽管友元函数的原型有在类的定义中出现过,但是友元函数并不是成员函数。 友元可以是一个函数,该函数被...
  • 友元函数的引用

    千次阅读 2019-04-03 18:22:38
    dispaly函数为普通函数(非类中),分别在Time,Date类中将display声明为友元函数,在主函数中调用dispaly函数,dispaly函数分别引用Time,Date中的私有数据成员,完成输出。 #include <iostream> #include <...
  • c++中友元函数理解与使用。

    万次阅读 多人点赞 2017-01-03 17:09:52
    在学习c++这一块,关于友元函数和友元类,感觉还是不好理解,但是井下心来,理解,需要把我一下几点。 首先讲友元函数。 (1)友元函数: 1)C++中引入友元函数,是为在该类中提供一个对外(除了他自己意外)访问的...
  • C++_友元函数

    千次阅读 2013-11-13 22:42:14
    1、为什么要引入友元函数:在实现类之间数据共享时,减少系统开销,提高效率  具体来说:为了使其他类的成员函数直接访问该类的私有变量  即:允许外面的类或函数去访问类的私有变量和保护变量,从而使两个类...
  • C++友元函数和友元类用法详解

    万次阅读 多人点赞 2018-01-21 21:12:37
    但是,有时需要定义一些函数,这些函数不是类的一部分,但又需要频繁地访问类的数据成员,这时可以将这些函数定义为该函数的友元函数。除了友元函数外,还有友元类,两者统称为友元。友元的作用是提高了程序的运行...
  • C++之中的友元函数的作用

    千次阅读 2017-12-09 20:05:56
    友元提供了不同类的成员函数之间、类的成员函数与一般函数之间进行数据共享的机制。通过友元,一个不同函数或另一个类中的成员函数可以访问类中的私有成员...友元函数友元函数是可以直接访问类的私有成员的非成员函
  • c++友元函数一些见解 1、为什么要引入友元函数:在实现类之间数据共享时,减少系统开销,提高效率 具体来说:为了使其他类的成员函数直接访问该类的私有变量 即:允许外面的类或函数去访问类的私有变量和保护变量,...
  • 在一个类中,可以利用关键字friend将其他的函数或类声明为友元,如果友元是一般函数或者类的成员函数,称为友元函数,如果友元是一个类,则成为友元类,友元类的所有成员函数都自动成为友元函数友元函数友元...
  • 友元函数 友元类 友元成员函数

    千次阅读 2018-05-07 22:34:40
    友元 一般来说,类内的私有数据是对外不可见的,但在有些情况下,我们需要在类外对该类的私有数据进行访问,这就需要用到一种新技术——友元(friend),即在声明前...友元函数是指某些非类成员函数,但可以访问类...
  • 我们在设计类时,一般...为了能够访问类私有成员,我们可以采用友元函数,在c++中以关键字friend加以声明,友元可以包括友元函数和友元类;友元函数又可以分为友元函数和友元成员函数;其一般形式分别如下:友元函数
  • 一、友元函数介绍  一般情况下,非类成员函数是不能访问成员变量的。但是有时候我们为了提高程序运行效率,希望外部函数能直接访问类的成员变量。此时我们可以使用友元。友元是一种允许非类成员函数访问类的非公有...
  • 运算符重载 对于面向对象的程序设计来说,运算符重载可以完成两个对象之间的复杂操作...为了重载运算符,首先要定义运算符重载函数,它通常是类的非静态成员函数或者友元函数,运算符的操作数通常也应为对象。 定...
  • C 友元函数与友元类

    2019-10-21 22:30:39
    C++友元函数与友元类 在C++中,一个类中可以有public、protected、private三种属性的成员,通过对象可以访问public成员,只有本类中的函数可以访问本类的private成员。所以,通过友元(friend)能够打破封装性。...
  • C++ 友元函数详解

    2017-07-11 11:24:59
    1、为什么要引入友元函数:在实现类之间数据共享时,减少系统开销,提高效率  具体来说:为了使其他类的成员函数直接访问该类的私有变量  即:允许外面的类或函数去访问类的私有变量和保护变量,从而使两个类...
  • 虚函数 和 友元函数

    千次阅读 2008-01-29 16:25:00
    友元可以是一个函数,该函数称为友元函数;友元也可以是一个类,该类被称为友元类。 友元函数 友元函数是能够访问类中的私有成员的非成员函数。 #include iostream.h> #include math.h> class Point ...{ ...
1 2 3 4 5 ... 20
收藏数 37,800
精华内容 15,120
关键字:

友元函数