精华内容
下载资源
问答
  •  一个类的私有数据成员通常只能由类的函数成员访问,而友元函数可以访问类的私有数据成员,也能访问其保护成员 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;
    }
    展开全文
  • 在类声明里实现友元函数 #include<bits/stdc++.h> using namespace std; class point { private : int a; public: point (int A=10) { a=A; } friend operator +(point A,point B) { ...

    方法一

    在类声明里实现友元函数

    #include<bits/stdc++.h>
    using namespace std;
    class point 
    {
    	private :
    		int a;
    	public:
    		point (int A=10)
    		{
    			a=A;
    		}
    		friend operator +(point A,point B)
    		{
    			cout<<A.a+B.a;
    		}
    	
    };
    int main()
    {
    	point obj1(1),obj2(5);
    	obj1+obj2;
    	return 0;
    }
    

    输出6

    方法二

    编写私有成员的外部接口

    #include<bits/stdc++.h>
    using namespace std;
    class point 
    {
    	private :
    		int a;
    	public:
    		point (int A=10)
    		{
    			a=A;
    		}
    		int get_a(){return a;};      //私有成员a的外部接口 
    		friend int operator+(point A,point B);
    };
    int operator+(point A,point B)
    {
    	return A.get_a()+B.get_a();
    }
    int main()
    {
    	point obj1(1),obj2(5);
    	cout<<obj1+obj2;
    	return 0;
    }
    

    输出 6

    以上两种方法是比较方便和可行的,当然还有其他方法了,这里就暂时不讨论了。

    展开全文
  •  一个类的私有数据成员通常只能由类的函数成员访问,而友元函数可以访问类的私有数据成员,也能访问其保护成员 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 

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

    输出结果:
    The sum of the 2 members is : 8

    转载:https://www.cnblogs.com/JCSU/articles/1044346.html 

     

    展开全文
  • C++友元函数访问类的私有成员

    千次阅读 2018-03-05 10:49:32
    在一些工程中我们经常需要访问某些类的静态成员,添加一个友元函数可以达到我们的目的。#include &lt;iostream&gt;#include&lt;cstring&gt;using namespace std ;class Student{private:string name...

    在一些工程中我们经常需要访问某些类的静态成员,添加一个友元函数可以达到我们的目的。

    #include <iostream>
    #include<cstring>
    using namespace std ;


    class Student{
    private:
    string  name; int age; int sore;
    public:
    Student(string name,int age,int sore)
    {
    this->name = name;
    this->age = age;
    this->sore = sore;
    }
    friend void Display(Student student);

    } ; 


    void Display(Student student)
    {
    cout<<student.name<<"\t"<<student.age<<"\t"<<student.sore<<endl;

    }


    int main(void)
    {
    Student a("TOM",13,96);

    Display(a);

    return 0;
    }

    展开全文
  • 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
  • 无法解决的问题:类中声明,类外定义的成员函数,导致无法访问类中的私有成员函数 去掉using namespace std; 改变#include <iostream>啥的都没用 苍了个天,走过路过的帮个忙? 真的是头大,跟着视频敲代码...
  • 友元函数是一个不属于类成员的函数,但它可以访问该类的私有成员。换句话说,友元函数被视为好像是该类的一个成员友元函数可以是常规的独立函数,也可以是其他类的成员。实际上,整个类都可以声明为另一个类的友元...
  • 在确认自己的代码无误后,确定一下你是否打过vcsp6补丁
  • 用的VS2019,出现标题中的问题,原来是类中声明友元函数时,有些地方没注明命名空间,不能丢,因为IDE也没这提示,一定要写全。
  • 类可以允许其他类或者是函数访问它的私有成员,方法是令其他类或者函数成为它的友员(friend) 为什么是友员? 友员可以破坏封装性,实现灵活性。 类中的成员访问说明符控制,公有成员可以被类的实例访问私有...
  • 友元函数 无法访问私有成员

    千次阅读 2011-05-27 07:58:00
    就会提示友员函数没有访问私有成员的权限。 解决方法:去掉using namespace std;换成更小的名字空间。 例如: 含有#include 就要加上using std::string 含有#include 就要加上using std::fstream 含有#...
  • 友元函数不能访问类的私有数据了。不知道为啥,求大佬指教,萌新虚心学习 下面是图片 先是complex类的 <p style="text-align:center"><img alt="" height="486" src=...
  • 问题是在看C++primer plus 私有继承部分出现的,按照书上的代码,在VS2015中发现编译不通过,提示为无法访问类的私有成员,该错误是在重载>>运算符时出现的,而其他友元函数访问私有成员未出现错误。 解决方法:将>...
  • 3.问题就在:友元函数定义时,访问不了类中的私有变量![图片说明](https://img-ask.csdn.net/upload/201905/16/1557972290_233414.png)![图片说明]...
  • #include "stdafx.h" #include "ioStream.h" #include "string.h" typedef char String[30];... CPerson(String Name,int Age)//构造函数 { strcpy(name,Name); age = Age; } friend char * GetName(CP.
  • 在一个类中,可以利用关键字friend将其他的函数或类声明为友元,如果友元是一般函数或者类的成员函数,称为友元函数,如果友元是一个类,则成为友元类,友元类的所有成员函数都自动成为友元函数友元函数友元...
  • //不设置友元的情况,类外的全局函数无法访问私有成员 #include <iostream> #include<string> using namespace std; class building { public: string m_bed; building(string name1, string name2) {...
  •  一个类的私有数据成员通常只能由类的函数成员访问,而友元函数可以访问类的私有数据成员,也能访问其保护成员 2. 友元函数的用处体现在哪里?  2.1 使用友元函数可提高性能,如:用友元函数重载...
  • //友元函数不分public和private,因为无论写哪外部都可以调用 //要声明可以对自己进行改变的其他类的成员函数 friend void Service::up(Computer* computer, string version);//对这个函数的声明必须写在前面,...
  • 友元类方法总结:1、包含声明”friend”的类,必须在((包含其声明的友元函数)的那个类)之前事先声明下————因为在Employer类中用到”Employee&”,不然无法访问该引用的私有成员。 2、被声明为友元的函数,必须...
  • 友元函数 友元类 友元成员函数

    千次阅读 2018-05-07 22:34:40
    友元 一般来说,类内的私有数据是对外不可见的,但在有些情况下,我们需要在类外对该类的私有数据进行访问,这就需要用到一种新技术——友元(friend),即在声明前...友元函数是指某些非类成员函数,但可以访问类...
  • 通过友元函数修改类的私有属性

    千次阅读 2018-04-01 12:34:55
    #include&lt;...//友元函数 class A { public: friend void modifyA(A *pA, int _a); A(int _a, int _b) { this-&gt;a = a; this-&gt;b = b; } int getA() { return thi...
  • 当声明了友元函数或者友元类之后,该函数或者类可以访问类的所有成员,包括private成员,当然访问过程需要通过类的对象进行。例如声明一个友元函数,有两种情况: ①该函数是普通的全局函数 一般情况下,使用一个...
  • MergeList模版友元函数的声明聪明的你发现什么错误没有,如果没发现,那么定义的时候会发现无法访问Node的私有成员。 下面是对MergeList的友元声明的改正: friend LinkList<type> MergeList(LinkList<type>...
  • 为什么80%的码农都做不了架构师?>>> ...
  • // lianxi4.1.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include using namespace std; class ClassAdd ... friend int ModifyMember(ClassAdd &Ca,int a,int b);//定义友元函数时注
  • 友元的目的:让一个函数或类 访问另一个类中私有成员 友元的三种实现: 全局函数友元 类做友元成员函数友元 #include <iostream> #include <string> using namespace std; //2.类做友元 class...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 22,214
精华内容 8,885
关键字:

友元函数无法访问私有成员