精华内容
下载资源
问答
  • C++ 友元函数详解

    2019-12-21 21:28:53
    1.友元函数的简单介绍 1.1为什么要使用友元函数 在实现类之间数据共享时,减少系统开销,提高效率。如果类A中的函数要访问类B中的成员(例如:智能指针类的实现),那么类A中该函数要是类B的友元函数。具体来说:...

    1.友元函数的简单介绍

    1.1为什么要使用友元函数

    在实现类之间数据共享时,减少系统开销,提高效率。如果类A中的函数要访问类B中的成员(例如:智能指针类的实现),那么类A中该函数要是类B的友元函数。具体来说:为了

    使其他类的成员函数直接访问该类的私有变量。即:允许外面的类或函数去访问类的私有变量和保护变量,从而使两个类共享同一函数。

    实际上具体大概有下面两种情况需要使用友元函数:(1)运算符重载的某些场合需要使用友元。(2)两个类要共享数据的时候。

    1.2使用友元函数的优缺点

    1.2.1优点:能够提高效率,表达简单、清晰。

    1.2.2缺点:友元函数破环了封装机制,尽量不使用成员函数,除非不得已的情况下才使用友元函数。

    2.友元函数的使用

    2.1友元函数的参数:

    因为友元函数没有this指针,则参数要有三种情况:

    2.1.1 要访问非static成员时,需要对象做参数;

    2.1.2 要访问static成员或全局变量时,则不需要对象做参数;

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

    2.2友元函数的位置

    因为友元函数是类外的函数,所以它的声明可以放在类的私有段或公有段且没有区别。

    2.3友元函数的调用

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

    2.4友元函数的分类:

    根据这个函数的来源不同,可以分为三种方法:

    2.4.1普通函数友元函数

    2.4.1.1 目的:使普通函数能够访问类的友元

    2.4.1.2 语法:

    声明: friend + 普通函数声明

    实现位置:可以在类外或类中

    实现代码:与普通函数相同

    调用:类似普通函数,直接调用

    2.4.1.3代码:

    class INTEGER

     {

      friend void Print(const INTEGER& obj);//声明友元函数

     };

    void Print(const INTEGER& obj)

    {

       //函数体

    }

    void main()

    {

      INTEGER obj;

      Print(obj);//直接调用

    }

    2.4.2Y的所有成员函数都为类X友元函数友元类

    2.4.2.1目的:使用单个声明使Y类的所有函数成为类X的友元,它提供一种类之间合作的一种方式,使类Y的对象可以具有类X和类Y的功能。

    2.4.2.2语法:

    声明位置:公有私有均可,常写为私有(把类看成一个变量)

    声明: friend + 类名(不是对象哦)

    2.4.2.3代码:

    class girl;

    class boy

    {

    public:

      void disp(girl &);

    };

    void boy::disp(girl &x) //函数disp()为类boy的成员函数,也是类girl的友元函数

    {

      cout<<"girl's name is:"<<x.name<<",age:"<<x.age<<endl;//借助友元,在boy的成员函数disp中,借助girl的对象,直接访问girl的私有变量

    }

    class girl

    {

    private:

      char *name;

      int age;

      friend boy; //声明类boy是类girl的友元

    };

    main函数就不写了和普通调用时一样的。

     

    2.4.3Y的一个成员函数为类X的友元函数

    2.4.3.1目的:使类Y的一个成员函数成为类X的友元,具体而言:在类Y的这个成员函数中,借助参数X,可以直接以X的私有变量

    2.4.3.2语法:

    声明位置:声明在公有中 (本身为函数)

    声明:friend + 成员函数的声明

    调用:先定义Y的对象y---使用y调用自己的成员函数---自己的成员函数中使用了友元机制

    2.4.3.3代码:

    实现代码和2.4.2.3中的实现及其相似只是设置友元的时候变为friend void boy::disp(girl &);自己解决喽……

     

    小结:其实一些操作符的重载实现也是要在类外实现的,那么通常这样的话,声明为类的友元是必须滴。

     

    4.友元函数和类的成员函数的区别

    4.1 成员函数有this指针,而友元函数没有this指针。

    4.2 友元函数是不能被继承的,就像父亲的朋友未必是儿子的朋友。

    展开全文
  • friend ostream & operator (ostream &output, const Vector &); 如果去掉 const 会编译错误 为什么? 下面贴代码 class Vector { public: Vector(int size); Vector(double *, int);... friend ostream & operator ...
  • template<class T1 ,class T2>... //友元函数类内实现 friend void printPerson( Person<T1 ,T2> & p ) { cout << "姓名:" << p.m_Name << " 年龄: " << p.m_Age &l...
    template<class T1 ,class T2>
    class Person
    {
    	//友元函数类内实现
    	friend void printPerson( Person<T1 ,T2> & p )
    	{
    		cout << "姓名:" << p.m_Name << "  年龄: " << p.m_Age << endl;
    	}
    public: 
    	Person(T1 name, T2 age)
    	{
    		this->m_Name = name;
    		this->m_Age = age;
    	}
    
    private:
    	T1 m_Name;
    	T2 m_Age;
    };
    
    void test01()
    {
    	Person<string, int> p("Tom", 10);
    	printPerson(p);
    }
    
    
    int main(){
    	test01();
    
    
    	system("pause");
    	return EXIT_SUCCESS;
    }

     

    展开全文
  • 关于C++中的friend友元函数的总结

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

    1.友元函数的简单介绍

    1.1为什么要使用友元函数

    在实现类之间数据共享时,减少系统开销,提高效率。如果类A中的函数要访问类B中的成员(例如:智能指针类的实现),那么类A中该函数要是类B的友元函数。
    具体来说:为了使其他类的成员函数直接访问该类的私有变量。即:允许外面的类或函数去访问类的私有变量和保护变量,从而使两个类共享同一函数。

    实际上具体大概有下面两种情况需要使用友元函数:(1)运算符重载的某些场合需要使用友元。(2)两个类要共享数据的时候。

    1.2使用友元函数的优缺点

    优点:能够提高效率,表达简单、清晰。

    缺点:友元函数破环了封装机制,尽量不使用成员函数,除非不得已的情况下才使用友元函数。

    2.友元函数的使用

    2.1友元函数的参数:

    因为友元函数没有this指针,则参数要有三种情况:

    要访问非static成员时,需要对象做参数;

    要访问static成员或全局变量时,则不需要对象做参数;

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

    2.2友元函数的位置

    因为友元函数是类外的函数,所以它的声明可以放在类的私有段或公有段且没有区别。

    2.3友元函数的调用

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

    2.4友元函数的分类:

    根据这个函数的来源不同,可以分为三种方法:

    普通函数友元函数:

    目的:使普通函数能够访问类的友元

    语法

    声明: friend + 普通函数声明

    实现位置:可以在类外或类中

    实现代码:与普通函数相同

    调用:类似普通函数,直接调用

    代码:

    class INTEGER
    
     {
    
      friend void Print(const INTEGER& obj);//声明友元函数
    
     };
    
    void Print(const INTEGER& obj)
    
    {
    
       //函数体
    
    }
    
    void main()
    
    {
    
      INTEGER obj;
    
      Print(obj);//直接调用
    
    }
    

    类Y的所有成员函数都为类X友元函数—友元类

    目的:使用单个声明使Y类的所有函数成为类X的友元,它提供一种类之间合作的一种方式,使类Y的对象可以具有类X和类Y的功能。

    语法

    声明位置:公有私有均可,常写为私有(把类看成一个变量)

    声明: friend + 类名(不是对象哦)

    代码

    class girl;
    
    class boy
    
    {
    
    public:
    
      void disp(girl &);
    
    };
    
    void boy::disp(girl &x) //函数disp()为类boy的成员函数,也是类girl的友元函数
    
    {
    
      cout<<"girl's name is:"<<x.name<<",age:"<<x.age<<endl;//借助友元,在boy的成员函数disp中,借助girl的对象,直接访问girl的私有变量
    
    }
    
    class girl
    
    {
    
    private:
    
      char *name;
    
      int age;
    
      friend boy; //声明类boy是类girl的友元
    
    };
    

    main函数就不写了和普通调用时一样的。

    类Y的一个成员函数为类X的友元函数

    目的:使类Y的一个成员函数成为类X的友元,具体而言:在类Y的这个成员函数中,借助参数X,可以直接以X的私有变量

    语法

    声明位置:声明在公有中 (本身为函数)

    声明:friend + 成员函数的声明

    调用:先定义Y的对象y—使用y调用自己的成员函数—自己的成员函数中使用了友元机制

    代码:

    实现代码和2.4.2.3中的实现及其相似只是设置友元的时候变为friend void boy::disp(girl &);

    小结:其实一些操作符的重载实现也是要在类外实现的,那么通常这样的话,声明为类的友元是必须滴。

    4.友元函数和类的成员函数的区别

    4.1 成员函数有this指针,而友元函数没有this指针。

    4.2 友元函数是不能被继承的,就像父亲的朋友未必是儿子的朋友。

    注意:

    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();  //调用类的成员函数。
    
    }
    
    

    关于要点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. C++中引入友元函数,是为在该类中提供一个对外(除了他自己意外)访问的窗口;

    2. 这个友元函数他不属于该类的成员函数,他是定义在类外的普通函数,只是在类中声明该函数可以直接访问类中的private或者protected成员。

    3. 将数据和处理数据的函数封装在一起,构成类,实现了数据的隐藏,无疑是面向对象程序设计的一大优点。但是有时候封装不是绝对的。

    4. 友元函数提供了不同类或对象的成员函数之间、类的成员函数和一般函数之间进行数据共享的机制。通俗的说,友元关系就是一个类主动声明哪些类或函数是它的朋友,进而给它们提供对本类的访问特性。也就是说,通过友元关系,一个普通函数或者类的成员函数可以访问封装于另外一个类中的数据。

    5. 从一定程度上讲,友元是对数据隐藏和封装的破坏,但是为了数据共享,提高程序的效率和可读性,很多情况下这种小的破坏是必要的。

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

    更多参考

    展开全文
  • #pragma once #include<iostream> #include<iomanip> using namespace std; class Student { int id; float score; public: Student(); Student(int i,float s):id(i),score(s){} ... void.
    #pragma once
    #include<iostream>
    #include<iomanip>
    using namespace std;
    
    class Student
    {
    	int id;
    	float score;
    public:
    	Student();
    	Student(int i,float s):id(i),score(s){}
    	friend Student Max(Student* StuArr, int len);
    	float GetScore();
    	void Print();
    };
    
    
    inline Student::Student()
    {
    	id = 0;
    	score = 0.0f;
    
    }
    
    
    inline float Student::GetScore()
    {
    	return score;
    }
    
    inline void Student::Print()
    {
    	cout << "学号:" << id << endl << "分数:" << score << endl << endl;
    }
    
    Student Max(Student* StuArr, int len)
    {
    	Student s;
    	for (int i = 0; i < len; i++)
    	{
    		if (s.score < StuArr[i].score)
    		{
    			s = StuArr[i];
    		}
    	}
    	return s;
    }
    
    
    /******************************************************
    *Complier:VS2017
    *Author:Rise
    *Project:对象数组
    *******************************************************/
    #include<iostream>
    #include"Student.h"
    using namespace std;
    
    
    int main()
    {
    	Student st[4] = {
    		{1001,98.2},
    		{1002,97.8},
    		{1003,99.0},
    		{1004,95.9}
    	};
    
    	Max(st, 4).Print();
    	return 0;
    }
    
    

     

    展开全文
  • ///将普通函数声明为友元函数。 private: int hour,minute,sec; }; class Date { public: Date(int ,int ,int); friend void display(Date &,Time &);///声明为友元函数 private: int month,day,year; }; ...
  • 一个双目运算符作为类的成员函数重载时,重载函数的参数表中有()个参数。 A.1 B.2 C.3 D.0 A 若为成员函数重载,参数一般为类对象的引用,另一个参数由this 指针所指向,故不...若为友元函数重载,则有两个参数! ...
  • 友元函数

    千次阅读 多人点赞 2018-09-03 10:27:37
    引入友元函数的原因 类具有封装、继承、多态、信息隐藏的特性,只有类的成员函数才可以访问类的私有成员,非成员函数只能访问类的公有成员。为了使类的非成员函数访问类的成员,唯一的做法就是将成员定义为public,...
  • 一、友元介绍我们知道,类的成员...friend 类型 友元函数名(参数表);友元的作用在于提高程序的运行效率 友元函数注意事项:1、友元函数不是类的成员函数,在函数体中访问对象的成员,必须用对象名加运算符“.”加对
  • 友元函数与友元类

    2021-03-19 20:43:19
    2.友元函数没有隐藏的this指针,故参数列表中要多一个类的参数,相当于this指针,但是不一定为第一个参数,这使得友元函数的操作更加灵活,能够完成一些成员函数无法完成的操作,使用友元函数将会使类的操作更加灵活...
  • 当声明了友元函数或者友元类之后,该函数或者类可以访问类的所有成员,包括private成员,当然访问过程需要通过类的对象进行。例如声明一个友元函数,有两种情况: ①该函数是普通的全局函数 一般情况下,使用一个...
  • 友元函数重载时,参数列表为1,说明是1元,为2说明是2元。成员函数重载时,参数列表为空,是一元,参数列表是1,为2元。
  • C++之中的友元函数的作用

    万次阅读 多人点赞 2017-12-09 17:23:22
    友元提供了不同类的成员函数之间、类的成员函数与一般函数之间进行数据共享的机制。通过友元,一个不同函数或另一个类中的成员函数可以访问类中的私有成员...友元函数友元函数是可以直接访问类的私有成员的非成员函
  • C++友元函数的定义和使用 <C++析构函数C++友元类> 类的封装性实现了数据隐藏,即类的私有成员在该类的作用域之外是不可见的。但有时可能需要在类的外部访问类的私有成员,为此 C++ 提供了一种允许类外的函数...
  • 首先友元函数是声明在类中的,作用是可以反问该类的私有成员(成员函数和成员参数)。其中,友元函数的声明跟平常函数声明基本一样,只需要在函数声明前加一个friend就行,友元函数的定义跟普通函数定义一模一样(不...
  • ①以下输出流重载为成员方法虽然解决了this指针抢占第一个参数的问题,但方法的调用必须用对象去驱动如下: t1 << cout ; 或 t1 << cout << endl; 这种输出流重载为成员方法不符合人的使用习惯 ...
  • 在一个类中,可以利用关键字friend将其他的函数或类声明为友元,如果友元是一般函数或者类的成员函数,称为友元函数,如果友元是一个类,则成为友元类,友元类的所有成员函数都自动成为友元函数友元函数友元...
  • 一、友元函数 1.友元函数概述: (1)友元函数是定义在一个类外的普通函数。 友元函数和普通函数的定义一样;在类内必须将该普通函数声明为友元。 (2)友元函数不是成员函数。 不能通过对象来调用,而是直接调用;友元函数...
  • 借助友元(friend),可以使得其他类中的成员函数以及全局范围内的函数访问当前类的 private 成员。friend 的意思是朋友,或者说是好友,与好友的关系显然要比一般人亲密一些。我们会对好朋友敞开心扉,倾诉自己的...
  • 关于友元函数

    千次阅读 2013-10-04 15:54:39
    1、为什么要引入友元函数: 类具有封装性和隐蔽性,只有类的成员函数才能访问类的私有成员,程序中的其他函数式无法访问类的私有成员。但是,有些时候,要求程序设计者必须确保每个类都能够提供足够的成员函数对所有...
  • 运算符重载为类的友元函数 友元函数通过类的对象可以访问类的公有、保护和私有成员,也就是类的所有成员友元函数都能访问到。所以运算符重载为类的友元函数以后也可以访问类的所有成员。 与运算符重载为成员函数时...
  • 文章目录022普通函数做类友元函数023友元类024友元成员函数 022普通函数做类友元函数 #include<iostream> #include<cstdlib> #include<string> #include<vector> using namespace std; ...
  • 友元函数,友元类

    2020-04-17 22:37:13
    友元函数: 知识点1.友元函数的作用:该函数可以直接访问对象的私有数据成员 知识点2.现在假设有一个类A,有一个函数B,函数B在类A外(可以在其他类内,也可以是普通的全局函数),在类A中用friend对函数B进行声明,...
  • c++友元函数和友元类详解

    千次阅读 2017-07-16 19:51:19
    我们在设计类时,一般...为了能够访问类私有成员,我们可以采用友元函数,在c++中以关键字friend加以声明,友元可以包括友元函数和友元类;友元函数又可以分为友元函数和友元成员函数;其一般形式分别如下:友元函数
  • 友元函数,内联函数

    2018-10-13 00:25:52
    类的友元函数是定义在类外部,但有权访问类的所有私有(private)成员和保护(protected)成员。尽管友元函数的原型有在类的定义中出现过,但是友元函数并不是成员函数。 友元可以是一个函数,该函数被称为友元函数...
  • 一、友元函数介绍  一般情况下,非类成员函数是不能访问成员变量的。但是有时候我们为了提高程序运行效率,希望外部函数能直接访问类的成员变量。此时我们可以使用友元。友元是一种允许非类成员函数访问类的非公有...
  • 3.11 友元函数和友元类 3.11.1 友元关系介绍 在前面章节讲过,类里面可以定义public、protected、private三种属性的成员,通过对象可以访问public成员,只有本类中的函数可以访问本类的private成员。 在C++里有一种...
  • 搬运自:... ... 友元包括友元函数、友元类 友元函数: 个人理解为在类中声明的可以外部访问类的内部成员变量的一个函数,这个函数并不是类的成员函数,只是在类中声明,而定义在类外。换...
  • C 友元函数与友元类

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

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 25,868
精华内容 10,347
关键字:

友元函数的参数