精华内容
下载资源
问答
  • 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;
    }


    展开全文
  • 在类声明里实现友元函数 #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

    实例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;
    }
    展开全文
  • 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;
    }

    展开全文
  • 无法解决的问题:类中声明,类外定义的成员函数,导致无法访问类中的私有成员函数 去掉using namespace std; 改变#include <iostream>啥的都没用 苍了个天,走过路过的帮个忙? 真的是头大,跟着视频敲代码...
  •  一个类的私有数据成员通常只能由类的函数成员访问,而友元函数可以访问类的私有数据成员,也能访问其保护成员 2. 友元函数的用处体现在哪里?  2.1 使用友元函数可提高性能,如:用友元函数重载操作符和生成迭代...
  • 友元函数是一个不属于类成员的函数,但它可以访问该类的私有成员。换句话说,友元函数被视为好像是该类的一个成员。友元函数可以是常规的独立函数,也可以是其他类的成员。实际上,整个类都可以声明为另一个类的友元...
  • 在一个类中,可以利用关键字friend将其他的函数或类声明为友元,如果友元是一般函数或者类的成员函数,称为友元函数,...虽然它不是本类的成员函数,但是在它的函数体中可以通过对象名访问类的私有和保护成员。 ...
  • 友元函数不能访问类的私有数据了。不知道为啥,求大佬指教,萌新虚心学习 下面是图片 先是complex类的 <p style="text-align:center"><img alt="" height="486" src=...
  • 在确认自己的代码无误后,确定一下你是否打过vcsp6补丁
  • 友元函数:如果在本类以外的地方定义的函数,在类中用friend声明,友元函数就可以访问这个类中的私有成员   1. 友元函数可以是另一个类的成员函数(友元成员函数),普通的函数   2.一个友元函数可以被多类声明为...
  • 类可以允许其他类或者是函数访问它的私有成员,方法是令其他类或者函数成为它的友员(friend) 为什么是友员? 友员可以破坏封装性,实现灵活性。 类中的成员受访问说明符控制,公有成员可以被类的实例访问私有...
  • 有些情况下,允许特定的非成员函数访问一个类的私有成员,同时仍阻止一般的访问,这是很方便做到的。例如被重载的操作符,如输入或输出操作符,经常需要访问类的私有数据成员。 友元(frend)机制允许一个类将对其...
  •  一个类的私有数据成员通常只能由类的函数成员访问,而友元函数可以访问类的私有数据成员,也能访问其保护成员 2. 友元函数的用处体现在哪里?  2.1 使用友元函数可提高性能,如:用友元函数重载...
  • 最近在使用友元函数访问私有成员时,遇到了问题,用一个类成员函数做另一个类的友元函数,但是一直报错,提示为定义其中的一个类型,思考良久(思路:既然友元函数在公有访问权限内,就应该可以访问私有数据成员)...
  • 为什么80%的码农都做不了架构师?>>> ...
  • 类有一个特点就是数据封装数据隐藏,也就是该类的私有成员以及保护成员只有通过它的成员才能访问。通过中的友元机制则解决了这一问题。友元既可以是独立的一个非成员函数,也可以是其他类中的成员函数,还可以一个...
  • 文章目录022普通函数做类友元函数023友元类024友元成员函数 022普通函数做类友元函数 #include<iostream> #include<cstdlib> #include<string> #include<vector> using namespace std; ...
  • 用的VS2019,出现标题中的问题,原来是类中声明友元函数时,有些地方没注明命名空间,不能丢,因为IDE也没这提示,一定要写全。
  • //不设置友元的情况,类外的全局函数无法访问私有成员 #include <iostream> #include<string> using namespace std; class building { public: string m_bed; building(string name1, string name2) {...
  • public继承,派生类的对象可以在类内访问基类的public和protected,在main函数内只能访问基类的public; protected继承,派生类的对象可以在类内访问基类的public和protected,并把基类的public和protected都变成...
  • 友元的目的:让一个函数或类 访问另一个类中私有成员 友元的三种实现: 全局函数友元 类做友元 类成员函数友元 #include <iostream> #include <string> using namespace std; //2.类做友元 class...
  • 搬运自:... ... 友元包括友元函数、友元类 友元函数: 个人理解为在类中声明的可以外部访问类的内部成员变量的一个函数,这个函数并不是类的成员函数,只是在类中声明,而定义在类外。换...
  • 当声明了友元函数或者友元类之后,该函数或者类可以访问类的所有成员,包括private成员,当然访问过程需要通过类的对象进行。例如声明一个友元函数,有两种情况: ①该函数是普通的全局函数 一般情况下,使用一个...
  • 3.问题就在:友元函数定义时,访问不了类中的私有变量![图片说明](https://img-ask.csdn.net/upload/201905/16/1557972290_233414.png)![图片说明]...
  • 友元函数 友元类 友元成员函数

    千次阅读 2018-05-07 22:34:40
    友元 一般来说,类内的私有数据是对外不可见的,但在有些情况下,我们需要在类外对该类的私有数据进行访问,这就需要用到一种新技术——友元(friend),即在声明前...友元函数是指某些非类成员函数,但可以访问类...
  • 首先介绍下友元函数的由来:友元函数是为了在类外的非成员函数去访问类的私有成员和保护成员的(但是注意,友元函数的增加会破坏类的封装性,因为非类的成员函数竟然也可以去访问 类的私有成员和保护成员了!!)。...
  • 把函数成为类的友元函数,函数就能访问类的所有成员成员变量,成员函数),忽视访问权限。 finend 函数定义放到类里,把函数生成成类的友元函数。 class Man : public Human //表示Men是Humen的子类 { private: ...
  • MergeList模版友元函数的声明聪明的你发现什么错误没有,如果没发现,那么定义的时候会发现无法访问Node的私有成员。 下面是对MergeList的友元声明的改正: friend LinkList<type> MergeList(LinkList<type>...

空空如也

空空如也

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

友元函数访问私有成员