精华内容
下载资源
问答
  • 借助友元(friend),可以使得其他类中的成员函数以及全局范围内的函数访问当前类的 private 成员。friend 的意思是朋友,或者说是好友,与好友的关系显然要比一般人亲密一些。我们会对好朋友敞开心扉,倾诉自己的...

    在C++中,一个类中可以有 public、protected、private 三种属性的成员,通过对象可以访问 public 成员,只有本类中的函数可以访问本类的 private 成员。现在,我们来介绍一种例外情况——友元(friend)。借助友元(friend),可以使得其他类中的成员函数以及全局范围内的函数访问当前类的 private 成员。

    friend 的意思是朋友,或者说是好友,与好友的关系显然要比一般人亲密一些。我们会对好朋友敞开心扉,倾诉自己的秘密,而对一般人会谨言慎行,潜意识里就自我保护。在 C++ 中,这种友好关系可以用 friend 关键字指明,中文多译为“友元”,借助友元可以访问与其有好友关系的类中的私有成员。如果你对“友元”这个名词不习惯,可以按原文 friend 理解为朋友。

    友元函数

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

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

    1) 将非成员函数声明为友元函数。

    请大家直接看下面的例子:

    #include <iostream>
    using namespace std;
    
    class Student{
    public:
        Student(char *name, int age, float score);
    public:
        friend void show(Student *pstu);  //将show()声明为友元函数
    private:
        char *m_name;
        int m_age;
        float m_score;
    };
    
    Student::Student(char *name, int age, float score): m_name(name), m_age(age), m_score(score){ }
    
    //非成员函数
    void show(Student *pstu){
        cout<<pstu->m_name<<"的年龄是 "<<pstu->m_age<<",成绩是 "<<pstu->m_score<<endl;
    }
    
    int main(){
        Student stu("小明", 15, 90.6);
        show(&stu);  //调用友元函数
        Student *pstu = new Student("李磊", 16, 80.5);
        show(pstu);  //调用友元函数
    
        return 0;
    }
    
    //运行结果:
    //小明的年龄是 15,成绩是 90.6
    //李磊的年龄是 16,成绩是 80.5

    show() 是一个全局范围内的非成员函数,它不属于任何类,它的作用是输出学生的信息。m_name、m_age、m_score 是 Student 类的 private 成员,原则上不能通过对象访问,但在 show() 函数中又必须使用这些 private 成员,所以将 show() 声明为 Student 类的友元函数。


    注意,友元函数不同于类的成员函数,在友元函数中不能直接访问类的成员,必须要借助对象。下面的写法是错误的:

    void show()
    {
        cout<<m_name<<"的年龄是 "<<m_age<<",成绩是 "<<m_score<<endl;
    }
    
    
    
    
    
    成员函数在调用时会隐式地增加 this 指针,指向调用它的对象,从而使用该对象的成员;而 show() 是非成员函数,没有 this 指针,编译器不知道使用哪个对象的成员,要想明确这一点,就必须通过参数传递对象(可以直接传递对象,也可以传递对象指针或对象引用),并在访问成员时指明对象。
    

    2) 将其他类的成员函数声明为友元函数

    friend 函数不仅可以是全局函数(非成员函数),还可以是另外一个类的成员函数。请看下面的例子:

    #include <iostream>
    using namespace std;
    
    class Address;  //提前声明Address类
    
    //声明Student类
    class Student{
    public:
        Student(char *name, int age, float score);
    public:
        void show(Address *addr);
    private:
        char *m_name;
        int m_age;
        float m_score;
    };
    
    //声明Address类
    class Address{
    private:
        char *m_province;  //省份
        char *m_city;  //城市
        char *m_district;  //区(市区)
    public:
        Address(char *province, char *city, char *district);
        //将Student类中的成员函数show()声明为友元函数
        friend void Student::show(Address *addr);
    };
    
    //实现Student类
    Student::Student(char *name, int age, float score): m_name(name), m_age(age), m_score(score){ }
    void Student::show(Address *addr){
        cout<<m_name<<"的年龄是 "<<m_age<<",成绩是 "<<m_score<<endl;
        cout<<"家庭住址:"<<addr->m_province<<"省"<<addr->m_city<<"市"<<addr->m_district<<"区"<<endl;
    }
    
    //实现Address类
    Address::Address(char *province, char *city, char *district){
        m_province = province;
        m_city = city;
        m_district = district;
    }
    
    int main(){
        Student stu("小明", 16, 95.5f);
        Address addr("陕西", "西安", "雁塔");
        stu.show(&addr);
       
        Student *pstu = new Student("李磊", 16, 80.5);
        Address *paddr = new Address("河北", "衡水", "桃城");
        pstu -> show(paddr);
    
        return 0;
    }
    
    //运行结果:
    //小明的年龄是 16,成绩是 95.5
    //家庭住址:陕西省西安市雁塔区
    //李磊的年龄是 16,成绩是 80.5
    //家庭住址:河北省衡水市桃城区


    本例定义了两个类 Student 和 Address,程序第 27 行将 Student 类的成员函数 show() 声明为 Address 类的友元函数,由此,show() 就可以访问 Address 类的 private 成员变量了。

    几点注意:
    ① 程序第 对Address 类进行了提前声明,是因为在 Address 类定义之前、在 Student 类中使用到了它,如果不提前声明,编译器会报错,提示'Address' has not been declared类的提前声明和函数的提前声明是一个道理。

    ② 程序将 Student 类的声明和实现分开了,而将 Address 类的声明放在了中间,这是因为编译器从上到下编译代码,show() 函数体中用到了 Address 的成员 province、city、district,如果提前不知道 Address 的具体声明内容,就不能确定 Address 是否拥有该成员(类的声明中指明了类有哪些成员)。

    ③ 一个函数可以被多个类声明为友元函数,这样就可以访问多个类中的 private 成员。

     

    友元类

    不仅可以将一个函数声明为一个类的“朋友”,还可以将整个类声明为另一个类的“朋友”,这就是友元类。友元类中的所有成员函数都是另外一个类的友元函数。

    例如将类 B 声明为类 A 的友元类,那么类 B 中的所有成员函数都是类 A 的友元函数,可以访问类 A 的所有成员,包括 public、protected、private 属性的。

    更改上例的代码,将 Student 类声明为 Address 类的友元类:

    #include <iostream>
    using namespace std;
    
    class Address;  //提前声明Address类
    
    //声明Student类
    class Student{
    public:
        Student(char *name, int age, float score);
    public:
        void show(Address *addr);
    private:
        char *m_name;
        int m_age;
        float m_score;
    };
    
    //声明Address类
    class Address{
    public:
        Address(char *province, char *city, char *district);
    public:
        //将Student类声明为Address类的友元类
        friend class Student;
    private:
        char *m_province;  //省份
        char *m_city;  //城市
        char *m_district;  //区(市区)
    };
    
    //实现Student类
    Student::Student(char *name, int age, float score): m_name(name), m_age(age), m_score(score){ }
    void Student::show(Address *addr){
        cout<<m_name<<"的年龄是 "<<m_age<<",成绩是 "<<m_score<<endl;
        cout<<"家庭住址:"<<addr->m_province<<"省"<<addr->m_city<<"市"<<addr->m_district<<"区"<<endl;
    }
    
    //实现Address类
    Address::Address(char *province, char *city, char *district){
        m_province = province;
        m_city = city;
        m_district = district;
    }
    
    int main(){
        Student stu("小明", 16, 95.5f);
        Address addr("陕西", "西安", "雁塔");
        stu.show(&addr);
       
        Student *pstu = new Student("李磊", 16, 80.5);
        Address *paddr = new Address("河北", "衡水", "桃城");
        pstu -> show(paddr);
    
        return 0;
    }

    将 Student 类声明为 Address 类的友元类,声明语句为:

    friend class Student;

    有的编译器也可以不写 class 关键字,不过为了增强兼容性还是建议写上。

    关于友元,有两点需要说明:

    • 友元的关系是单向的而不是双向的。如果声明了类 B 是类 A 的友元类,不等于类 A 是类 B 的友元类,类 A 中的成员函数不能访问类 B 中的 private 成员。
    • 友元的关系不能传递。如果类 B 是类 A 的友元类,类 C 是类 B 的友元类,不等于类 C 是类 A 的友元类。

    除非有必要,一般不建议把整个类声明为友元类,而只将某些成员函数声明为友元函数,这样更安全一些。

    展开全文
  • 今天在牛客网刷题的时候遇到这样一个题,和大家分享一下 这道题我做错了,看完解析之后还是有些似懂非懂,于是去查看了一些友元函数和友元类的相关资料,给大家...D:在外部定义友元函数时,不必加关键字friend 友...

    今天在牛客网刷题的时候遇到这样一个题,和大家分享一下
    牛客网
    这道题我做错了,看完解析之后还是有些似懂非懂,于是去查看了一些友元函数和友元类的相关资料,给大家分享一下,首先我们先来分析一下这个题:

    • A:在C++中友元函数是独立于当前类的外部函数
    • B:一个友元函数可以同时定义为两个类的友元函数
    • C:友元函数既可以在类的内部,也可以在类的外部定义;
    • D:在外部定义友元函数时,不必加关键字friend

    友元的定义

    • 友元提供了不同类的成员函数之间、类的成员函数与一般函数之间进行数据共享的机制。通过友元,一个不同函数或另一个类中的成员函数可以访问类中的私有成员和保护成员
    • c++中的友元为封装隐藏这堵不透明的墙开了一个小孔,外界可以通过这个小孔窥视内部的秘密。
    • 友元的正确使用能提高程序的运行效率,但同时也破坏了类的封装性和数据的隐藏性,导致程序可维护性变差,因此友元不建议多使用和乱使用。

    友元函数 :

    • 友元函数是可以直接访问类的私有成员和保护成员。它是定义在类外的普通函数,它不属于任何类,但需要在类的定义中加以声明,声明时只需在友元的名称前加上关键字friend,其格式如下:

    friend 类型 函数名(形式参数);

    • 友元函数的声明可以放在类的私有部分,也可以放在公有部分,它们是没有区别的,都说明是该类的一个友元函数。
    • 友元函数既可以在类的内部,也可以在类的外部定义,在外部定义友元函数时,不必加关键字friend
    • 一个函数可以是多个类的友元函数,只需要在各个类中分别声明。
    • 友元函数的调用与一般函数的调用方式和原理一致。

    友元类 :

    • 友元类的所有成员函数都是另一个类的友元函数,都可以访问另一个类中的隐藏信息(包括私有成员和保护成员)。
    • 当希望一个类可以存取另一个类的私有成员时,可以将该类声明为另一类的友元类。定义友元类的语句格式如下:

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

    举个栗子看看友元函数和友元类

    class Radius
    {
    	friend class Circle;            //声明Circle为Radius的友元类
    	friend void Show_r(Radius &n);     //声明Show_r为友元函数
    public:
    	Radius(int x)
    	{
    		r = x;
    	}
    	~Radius(){}
    		
    private:
    	int r;
    };
    
    void Show_r(Radius &n)//友元函数可在类外定义,不用加关键字friend
    {
    	     cout << "圆的半径为: " << n.r << endl;    //友元函数可以调用Radius对象的私有成员变量r
    	 }
    
    class Circle
    {
     public:
    	 Circle(){}
    	~Circle(){}
    	 double area(Radius a)
    	 {
    		 s = a.r * a.r * 3.1415926;   //友元类可调用Radius对象的私有成员变量r
    		 return s;
    	 }
    private:
    	double s;
    };
    int main()
    {
    	Radius objRadius(9);
    	Circle objCircle;
    	Show_r(objRadius);
    	cout << "面积为:" << objCircle.area(objRadius) << endl;
    	
    	return 0;
    }
    

    友元函数和友元类
    一个函数可以被声明为两个类的友元

    //一个函数可以被两个类声明为友元
    class Teacher;//只申明
    class Student
    {
    public:
    	friend bool is_equal(Student&,Teacher&);
    private:
    	int _sid;
    };
    
    class Teacher
    {
    public:
    	friend bool is_equal(Student&, Teacher&);
    private:
    	int _tid;
    };
    

    使用友元类时注意:

    • (1) 友元关系不能被继承,举个栗子:若A是B的友元,C是A的派生类,C不是B的友元。
    • (2) 友元关系是单向的,不具有交换性。举个栗子:若类B是类A的友元,类A不一定是类B的友元,要看在类中是否有相应的声明。
    • (3) 友元关系不具有传递性。举个栗子:若类B是类A的友元,类C是B的友元,类C不一定是类A的友元,同样要看类中是否有相应的申明
    展开全文
  • C++友元函数定义和使用 <C++析构函数C++友元类> 类的封装性实现了数据隐藏,即类的私有成员在该类的作用域之外是不可见的。但有时可能需要在类的外部访问类的私有成员,为此 C++ 提供了一种允许类外的函数...

    本文参考:http://www.itxueyuan.org/view/100.html

    C++析构函数C++友元类 >

    类的封装性实现了数据隐藏,即类的私有成员在该类的作用域之外是不可见的。但有时可能需要在类的外部访问类的私有成员,为此 C++ 提供了一种允许类外的函数或其他的类访问该类的私有成员的方法,它通过关键字 friend 把其他类或函数声明为一个类的友元。

    友元的使用就好比一个独立的个人,私有成员是个人的秘密,本来对外界是保密的,但对于好朋友却没必要隐藏,这样好朋友就可以了解个人的所有秘密。在编程中,如果模拟空调和遥控器的程序,就可以使用友元关系来处理,遥控器不是空调或空调的一部分,但可以改变空调的状态。

    本节只讲解 C++ 友元函数,C++ 友元类将在下节讲解。

    友元函数是声明在类体内的一般函数,也可以是另一个类中的成员函数。友元函数并不是这个类中的函数,但它具有这个类中成员函数所具有的访问该类所有成员的功能。接下来分两种情况讨论友元函数。

    C++普通函数作为友元函数

    普通函数作为友元函数,其语法格式如下:

    friend 函数返回值类型 函数名(形式参数列表);


    接下来演示普通函数作为友元函数的用法,如例 1 所示。

    【例 1】

    #include <iostream>
    #include <cmath>
    using namespace std;
    class Point
    {
    public:
    Point(int a = 0, int b = 0)
    {
    x = a;
    y = b;
    }
    void print()
    {
    cout << "(" << x <<","<< y<< ")";
    }
    friend double Distance(Point a, Point b); //友元函数的声明
    private:
    int x, y;
    };
    double Distance(Point a, Point b) //友元函数的定义
    {
    int x = a.x - b.x;
    int y = a.y - b.y;
    return sqrt(x * x + y * y);
    }
    int main()
    {
    Point p1(3, 4), p2;
    double d = Distance(p1, p2); //友元函数的调用
    p1.print();
    p2.print();
    cout << " 距离为"<< d << endl;
    return 0;
    }

    程序执行结果为:

    (3,4)(0,0) 距离为5

    在例 1 中,Point 类中声明了一个友元函数,它是普通函数定义在类体外。友元函数中通过指定的对象访问了类中的私有数据成员,并进行了运算。

    C++类中的成员函数作为另一个类的友元函数

    类中的成员函数作为另一个类的友元函数,其语法格式如下:

    friend 类名::函数返回值类型 函数名(形式参数列表);


    接下来演示类中的成员函数作为另一个类的友元函数的用法,如例 2 所示。

    【例 2】

    #include <iostream>
    using namespace std;
    class B; //声明B类
    class A //定义A类
    {
    public:
    A(int x = 0)
    {
    a = x;
    }
    void print()
    {
    cout << "A: a = " << a << endl;
    }
    void func(B &var);
    private:
    int a;
    };
    class B //定义 B 类
    {
    public:
    B(int y = 0)
    {
    b = y;
    }
    void print()
    {
    cout << "B: b = " << b << endl;
    }
    friend void A::func(B &var); //将 A 类中的成员函数 func() 声明为 B 类的友元函数
    private:
    int b;
    };
    void A::func(B &var) //友元函数的定义
    {
    a = var.b;
    }
    int main()
    {
    A m(2);
    m.print();
    B y(3);
    y.print();
    m.func(y); //友元函数的调用
    m.print();
    return 0;
    }

    程序执行结果为:

    A: a = 2
    B: b = 3
    A: a = 3

    在例 2 中,第 3 行必须声明 B 类,因为只有 A 类完整定义过之后,才能定义友元的 B 类,而A类中又使用了“B”这个标识符,因此就需要使用类的声明。类的声明并不是对类的完整定义,它只是告诉编译器标识符的含义,一个只有声明的类是不能实例化的。

    在使用友元函数时,还需要注意以下几点:

    • 友元函数必须在类的定义中声明;
    • 友元函数的声明可以出现在类的任何地方,包括在 private 和 protected 部分;
    • C++ 不允许将某个类的构造函数、析构函数和虚函数声明为友元函数。
    • C++primer5th上250页说,不完全类型只能在以下情况使用(1)可以定义指向这种类型的指针或引用(2)可以声明(不能定义)以不完全类型作为参数或者返回类型的函数。

     

    我自己写了一个程序,证明不完全类型也可以声明指向它自己类型的引用。(估计定义指向它的指针也可以),如下:

    #include <iostream>
    #include <string>
    using namespace std;
    class Test{
    	public:
    		Test() = default;
    		Test(int k1,int k2):i(k1),j(k2){}
    		void print()const;
    		void fun(Test &t);//这里,Test还没没定义完,还是个不完全类型。结果通过编译
    	private:
    		int i;
    		int j;
    };
    void Test::print()const
    {
    cout << i << endl;
    cout << j << endl;
    }
    void Test::fun(Test &t)
    {
       if(i > 0) {cout << "first private data's sum:" << i + t.i<< endl;}
       if(j > 0) {cout <<"second private data's sum:."<< j+ t.j << endl;}
    }
    int main()
    {
    Test t1(1,2);
    Test t2(100,200);
    t1.print();
    t1.fun(t2);
    
    
    return 0;
    }

    结论,不完全类型可以声明它的引用。

    展开全文
  • 友元函数(friend)

    2019-08-14 21:44:32
    类的友元函数定义在类外部,但有权访问类的所有私有(private)成员和保护(protected)成员。尽管友元函数的原型有在类的定义中出现过,但是友元函数并不是成员函数。 友元可以是一个函数,该函数被称为友元函数...

           类的友元函数是定义在类外部,但有权访问类的所有私有(private)成员和保护(protected)成员。尽管友元函数的原型有在类的定义中出现过,但是友元函数并不是成员函数。

    友元可以是一个函数,该函数被称为友元函数;友元也可以是一个类,该类被称为友元类,在这种情况下,整个类及其所有成员都是友元。

    如果要声明函数为一个类的友元,需要在类定义中该函数原型前使用关键字friend,如下所示:

    class Box
    {
       double width;
    public:
       double length;
       friend void printWidth( Box box );
       void setWidth( double wid );
    };
    #include <iostream>
     
    using namespace std;
     
    class Box
    {
       double width;
    public:
       friend void printWidth( Box box );
       void setWidth( double wid );
    };
    
    // 成员函数定义
    void Box::setWidth( double wid )
    {
        width = wid;
    }
    
    // 请注意:printWidth() 不是任何类的成员函数
    void printWidth( Box box )
    {
       /* 因为 printWidth() 是 Box 的友元,它可以直接访问该类的任何成员 */
       cout << "Width of box : " << box.width <<endl;
    }
     
    // 程序的主函数
    int main( )
    {
       Box box;
     
       // 使用成员函数设置宽度
       box.setWidth(10.0);
       
       // 使用友元函数输出宽度
       printWidth( box );
     
       return 0;
    }
    

    运行结果:

    Width of box : 10

     

    展开全文
  • 一、友元函数  1、友元函数允许在类外访问该类中的任何成员,使用关键字friend说明... 友元函数不属于该类的成员函数,它是定义在类外的普通函数,只是在类中通过friend关键字声明,从而使该函数可以访问类中的pr...
  • 友元函数friend

    2017-11-05 14:30:43
    学过C++的程序员都知道,一个常规的成员函数声明描述了三件在逻辑上相互不同的事情: 1、该函数能访问类声明的私用部分。...什么是友元函数友元函数友元函数可以直接访问类的私有成员,它是定义在类外部的普
  • C++——友元函数&内联函数

    千次阅读 多人点赞 2018-12-07 23:55:15
    类的友元函数定义在类外部,但有权访问类的所有私有(private)成员和保护(protected)成员。尽管友元函数的原型有在类的定义中出现过,但是友元函数并不是成员函数。 友元可以是一个函数,该函数被称为友元函数...
  • 文章目录声明成员函数友元函数类模板内实现重新定义一个函数模板 声明 类模板的声明语法如下 template<typename 类型参数, typename 类型参数, ...> class className { //TODO; } 这里面的typename相当于一种...
  • C++的友元函数

    2019-07-13 18:20:44
    类的主要特点之一是数据隐藏和封装,即类的私有成员(或保护成员)只能在类定义的范围内使用,也就是说私有成员只能通过他的成员函数来访问。但是,有时为了访问类的私有成员而需要在程序中多次调用成员函数,这样会...
  • 在一个类中,可以利用关键字friend将其他的函数或类声明为友元,如果友元是一般函数或者类的成员函数,称为友元函数,如果友元是一个类,则成为友元类,友元类的所有成员函数都自动成为友元函数友元函数友元...
  • 二、友元函数友元函数在类作用域外定义,但它需要在类体中进行说明为了与该类的成员函数加以区别,定义的方式是在类中用关键字friend说明该函数,格式如下: friend 类型 友元函数名(参数表);友元的作用在于提高...
  • 但有时可能需要在类的外部访问类的私有成员,为此 C++ 提供了一种允许类外的函数或其他的类访问该类的私有成员的方法,它通过关键字friend把其他类或函数声明为一个类的友元友元的使用就好比一个独立的个人,私有...
  • 友元函数 需要友元解决的问题: 运用operator<<进行函数重载,需要输出,若把operator<<定义为成员变量函数,因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认是第一个参数也...
  • 我们平常使用友元函数都仅是在类内部声明,在类外定义,今天看到了一个在类内定义的例子,就产生了好奇,把自己的总结记录下来; 先看例子 1 class T 2 { 3 public: 4 T(); 5 ~T(); 6 7 //不引入...
  •   在不放弃私有成员(或保护成员)数据安全性的情况下,使得一个普通函数或者类的成员函数可以访问到封装在某一类中的信息...既可以是不属于任何类的非成员函数,也可以是另一个类的成员函数,统称为友元函数...
  • 友元函数

    千次阅读 多人点赞 2018-09-03 10:27:37
    引入友元函数的原因 类具有封装、继承、多态、信息隐藏的特性,只有类的成员函数才可以访问类的私有成员,非成员函数只能访问类的公有成员。为了使类的非成员函数访问类的成员,唯一的做法就是将成员定义为public,...
  • C++之友元函数的类外实现和调用

    千次阅读 2019-07-03 20:40:06
    // 友元函数重载:用友元函数重载 << >> // friend iosteam & operator<< <T>(ostream&out, Complex<T> &c3) // 友元函数友元函数不是实现函数重载(非<< >&...
  • C++ 类(友元函数和友元类)

    千次阅读 2018-07-19 16:56:20
    友元函数的作用: 可以在类的外部访问类的私有属性,但是会破坏类的封装。 b. 友元函数的格式: friend 函数返回类型 函数名(参数列表)。 c. 友元函数声明的位置和类访问修饰符无关。 //对象的成员必须初始化 ...
  • 文章目录022普通函数做类友元函数023友元类024友元成员函数 022普通函数做类友元函数 #include<iostream> #include<cstdlib> #include<string> #include<vector> using namespace std; ...
  • 友元函数和友元类

    2021-05-26 22:40:49
    友元的概念: 遵循一定规则而使对象以外的软件...3.友元函数可以在类定义的任何地方声明,不受类访问限定符限制 4.一个函数可以是多个类的友元函数 在类的定义中用friend声明了一个外部函数或其他类的成员函数(publ
  • 友元函数和重载

    千次阅读 2018-07-11 10:54:42
    友元函数:类的友元函数定义在类外部,但有权访问类的所有私有(private)成员和保护(protected)成员。尽管友元函数的原型有在类的定义中出现过,但是友元函数并不是成员函数。友元可以是一个函数,该函数被称为...
  • 类的友元函数可直接访问类中的私有成员变量,该函数是定义在类外的普通函数,不属于任何类,需要在类中加friend关键字声明。 比如我们在重载自定义类型输入输出操作符时就需要将操作符重载函数声明为友元函数: class...
  • 一、友元函数 1、友元函数 友元函数不是当前类的成员函数,但它可以访问该类所有的成员,包括私有成员、保护成员和公有成员。 在类中声明友元函数时,需在其函数名前加上关键字 friend。 友元函数既可以...
  • 一、友元函数介绍  一般情况下,非类成员函数是不能访问成员变量的。但是有时候我们为了提高程序运行效率,希望外部函数能直接...友元函数在类作用域外定义,但它需要在类体中进行说明,为了与该类的成员函数加以区
  • 搬运自:... ... 友元包括友元函数、友元类 友元函数: 个人理解为在类中声明的可以外部访问类的内部成员变量的一个函数,这个函数并不是类的成员函数,只是在类中声明,而定义在类外。换...
  • 友元函数,内联函数

    2018-10-13 00:25:52
    类的友元函数定义在类外部,但有权访问类的所有私有(private)成员和保护(protected)成员。尽管友元函数的原型有在类的定义中出现过,但是友元函数并不是成员函数。 友元可以是一个函数,该函数被称为友元函数...
  • 重复定义问题,出现在 其他类成员作为友元函数的时候 (1). 在A类的声明中写下函数 (2). 在A类外给出具体定义 / 在A类声明中直接给出定义都会导致-> (3). 之后再在目标类中写下 friend void A::function 就会报错...
  • c++友元函数声明及其调用

    万次阅读 2017-09-26 10:59:12
    友元函数入门!!!
  • 3.11 友元函数和友元类 3.11.1 友元关系介绍 在前面章节讲过,类里面可以定义public、protected、private三种属性的成员,通过对象可以访问public成员,只有本类中的函数可以访问本类的private成员。 在C++里有一种...
  • C++友元函数简单示例

    千次阅读 2019-06-19 10:23:30
    在我看来,友元函数就是提供一种方式,让外部的函数能够访问的了内部类的私有变量的一种形式,破坏了封装性,所以本人比较少看到公司项目用到这个方式。 示例代码: #include "stdafx.h" ...

空空如也

空空如也

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

外部定义友元函数