精华内容
下载资源
问答
  • 友元类及友元关系

    2020-02-15 16:21:25
    #define _CRT_SECURE_NO_WARNINGS #include <iostream> #include <cstring>...友元关系是单向的,具备交换性 类B是A的友元,反之未必 //3.友元关系不具备传递性 B是A的友元 C是B的...
    #define _CRT_SECURE_NO_WARNINGS
    #include <iostream>
    #include <cstring>
    #include <cmath>
    using namespace std;
    //1.友元关系不能被继承
    //2.友元关系是单向的,不具备交换性 类B是A的友元,反之未必
    //3.友元关系不具备传递性 B是A的友元 C是B的友元 但C不一定是A的友元
    class A{
    public:
    	A(int a){
    		this->m_a=a;
    	}
    	void printA(){
    		cout<<"m_a: "<<m_a<<endl;
    	}
    	friend class B;//声明友元类
    private:
    	int m_a;
    };
    class B{
    public:
    	B(int b){
    		this->m_b=b;
    	}
    	void printB(){
    		A a(1000);
    		cout<<"m_a: "<<a.m_a<<endl;
    		cout<<"m_b: "<<m_b<<endl;
    	}
    private:
    	int m_b;
    };
    
    int main(){
    	B b(10);
    	b.printB();
    	system("pause");
    	return 0;
    }
    
    展开全文
  • c++6(友元关系)

    2018-06-25 18:23:45
     友元(frend)机制允许一个类将对其非公有成员的访问权授予指定的函数或者类,友元的声明以friend开始,它只能出现在类定义的内部,友元声明可以出现在类中的任何地方:友元不是授予友元关系的那个类的成员,所以它....

         有些情况下,允许特定的非成员函数访问一个类的私有成员,同时仍阻止一般的访问,这是很方便做到的。例如被重载的操作符,如输入或输出操作符,经常需要访问类的私有数据成员。

            友元(frend)机制允许一个类将对其非公有成员的访问权授予指定的函数或者类,友元的声明以friend开始,它只能出现在类定义的内部,友元声明可以出现在类中的任何地方:友元不是授予友元关系的那个类的成员,所以它们不受其声明出现部分的访问控制影响。通常,将友元声明成组地放在类定义的开始或结尾是个好主意。

    1、友元函数

         友元函数是指某些虽然不是类成员函数却能够访问类的所有成员的函数。类授予它的友元特别的访问权,这样该友元函数就能访问到类中的所有成员。

    复制代码
    #include <iostream>
    
    using namespace std;
    
    class A
    {
    public:
        friend void set_show(int x, A &a);      //该函数是友元函数的声明
    private:
        int data;
    };
    
    void set_show(int x, A &a)  //友元函数定义,为了访问类A中的成员
    {
        a.data = x;
        cout << a.data << endl;
    }
    int main(void)
    {
        class A a;
    
        set_show(1, a);
    
        return 0;
    }
    复制代码

    2、友元类

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

    关于友元类的注意事项:

    (1) 友元关系不能被继承。
    (2) 友元关系是单向的,不具有交换性。若类B是类A的友元,类A不一定是类B的友元,要看在类中是否有相应的声明。
    (3) 友元关系不具有传递性。若类B是类A的友元,类C是B的友元,类C不一定是类A的友元,同样要看类中是否有相应的申明。

    复制代码
    #include <iostream>
    
    using namespace std;
    
    class A
    {
    public:
        friend class C;                         //这是友元类的声明
    private:
        int data;
    };
    
    class C             //友元类定义,为了访问类A中的成员
    {
    public:
        void set_show(int x, A &a) { a.data = x; cout<<a.data<<endl;}
    };
    
    int main(void)
    {
        class A a;
        class C c;
    
        c.set_show(1, a);
    
        return 0;
    }
    复制代码

    3、友元成员函数

            使类B中的成员函数成为类A的友元函数,这样类B的该成员函数就可以访问类A的所有成员了。

            当用到友元成员函数时,需注意友元声明和友元定义之间的相互依赖,在该例子中,类B必须先定义,否则类A就不能将一个B的函数指定为友元。然而,只有在定义了类A之后,才能定义类B的该成员函数。更一般的讲,必须先定义包含成员函数的类,才能将成员函数设为友元。另一方面,不必预先声明类和非成员函数来将它们设为友元。

    复制代码
    #include <iostream>
    
    using namespace std;
    
    class A;    //当用到友元成员函数时,需注意友元声明与友元定义之间的互相依赖。这是类A的声明
    class B
    {
    public:
        void set_show(int x, A &a);             //该函数是类A的友元函数
    };
    
    class A
    {
    public:
        friend void B::set_show(int x, A &a);   //该函数是友元成员函数的声明
    private:
        int data;
        void show() { cout << data << endl; }
    };
    
    void B::set_show(int x, A &a)       //只有在定义类A后才能定义该函数,毕竟,它被设为友元是为了访问类A的成员
    {
        a.data = x;
        cout << a.data << endl;
    }
    
    int main(void)
    {
        class A a;
        class B b;
    
        b.set_show(1, a);
    
        return 0;
    }
    复制代码

    友元小结:

            在需要允许某些特定的非成员函数访问一个类的私有成员(及受保护成员),而同时仍阻止一般的访问的情况下,友元是可用的。

    优点:

            可以灵活地实现需要访问若干类的私有或受保护的成员才能完成的任务;

            便于与其他不支持类概念的语言(如C语言、汇编等)进行混合编程;

            通过使用友元函数重载可以更自然地使用C++语言的IO流库。

    缺点:

            一个类将对其非公有成员的访问权限授予其他函数或者类,会破坏该类的封装性,降低该类的可靠性和可维护性。

    展开全文
  • 友元函数和友元

    2019-06-28 16:59:49
    采用类的机制后实现了数据的隐藏与封装,类的数据成员一般定义为私有成员,成员函数一般定义为公有...友元的作用是提高了程序的运行效率(即减少了类型检查和安全检查等都需要时间开销),但它破坏了类的封装和...

    采用类的机制后实现了数据的隐藏与封装,类的数据成员一般定义为私有成员,成员函数一般定义为公有的,依此提供类与外界间的通信接口。但是,有时需要定义一些函数,这些函数不是类的一部分,但又需要频繁地访问类的数据成员,这时可以将这些函数定义为该函数的友元函数。除了友元函数外,还有友元类,两者统称为友元。友元的作用是提高了程序的运行效率(即减少了类型检查和安全性检查等都需要时间开销),但它破坏了类的封装性和隐藏性,使得非成员函数可以访问类的私有成员。

     

    一、友元函数

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

     

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

     

    友元函数的声明可以放在类的私有部分,也可以放在公有部分,它们是没有区别的,都说明是该类的一个友元函数。

    一个函数可以是多个类的友元函数,只需要在各个类中分别声明。

    友元函数的调用与一般函数的调用方式和原理一致。

     

    友元函数例子:

    #include <iostream>

    #include <math.h>

    using namespace std;

     

    class APoint

    {

    private:

             double x;

             double y;

    public:

             APoint(double x, double y);

             void getCoordinates();

             friend double getDistance(const APoint&, const APoint&);

    };

     

    APoint::APoint(double x, double y)

    {

             this->x = x;

             this->y = y;

    }

     

    void APoint::getCoordinates()

    {

             cout << "(" << x << ", " << y << ")" << endl;

    }

     

    double getDistance(const APoint& a, const APoint& b)

    {

             return sqrt(pow((a.x - b.x), 2.0) + pow((a.y - b.y), 2.0));

    }

     

    int main()

    {

             APoint p1(3, 4);

             APoint p2(11, 12);

     

             p1.getCoordinates();

             p2.getCoordinates();

     

             double d = getDistance(p1, p2);

             cout << "The distance between p1 and p2 is: " << d << endl;

     

             return 0;

    }

     

    二、友元类

    友元类的所有成员函数都是另一个类的友元函数,都可以访问另一个类中的隐藏信息(包括私有成员和保护成员)。      

     

    当希望一个类可以存取另一个类的私有成员时,可以将该类声明为另一类的友元类。定义友元类的语句格式如下:

          friend class 类名;

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

     

    例如,以下语句说明类B是类A的友元类:

          class A

          {

                 …

          public:

                 friend class B;

                 …

          };

    经过以上说明后,类B的所有成员函数都是类A的友元函数,能存取类A的私有成员和保护成员。

     

    使用友元类时注意:

    (1)   友元关系不能被继承。

    (2)   友元关系是单向的,不具有交换性。若类B是类A的友元,类A不一定是类B的友元,要看在类中

    是否有相应的声明。

    (3)       友元关系不具有传递性。若类B是类A的友元,类C是B的友元,类C不一定是类A的友元,同样

    要看类中是否有相应的申明

     

    友元类例子:

    // ------------------------------------------

    // example: 友元类

    #include <iostream>

    #include <math.h>

    using namespace std;

     

    // class AFriendAPoint;      没有必要在此预先声明AFriendPoint类

     

    class APoint

    {

    private:

             double x;

             double y;

    public:

             APoint(double x, double y)

             {

                       this->x = x;

                      this->y = y;

             }

             friend class AFriendPoint;

    };

     

    class AFriendPoint

    {

    public:

             void getCoordinates(const APoint&);

             double getDistance(const APoint&, const APoint&);

    };

     

    void AFriendPoint::getCoordinates(const APoint& p)

    {

             cout << "This coordinates of this point is: (" << p.x << ", " << p.y << ")" << endl;

    }

     

    double AFriendPoint::getDistance(const APoint& a, const APoint& b)

    {

             return sqrt(pow((a.x - b.x), 2.0) + pow((a.y - b.y), 2.0));

    }

     

    int main()

    {

             APoint p1(3, 4);

             APoint p2(4, 5);

             AFriendPoint* afp = new AFriendPoint;

             afp->getCoordinates(p1);

             afp->getCoordinates(p2);

            

             double the_distance = afp->getDistance(p1, p2);

             cout << "The distance between those 2 points is: " << the_distance << endl;

     

             delete afp;

     

             return 0;

    }

    转载于:https://www.cnblogs.com/sjlove/p/3169661.html

    展开全文
  • C++是一个更好的C,它保持了C的简洁、高效、接近汇编语言、具有良好的可读性和可移植等特点,对C的类型系统进行了改革和扩充,因此C++比C更安全,C++的编译系统能检查出更多的类型错误。 C++语言最重要的特点是...
  • 友元

    2019-11-24 21:41:14
    (2) 友元关系是单向的,不具有交换性。若类B是类A的友元,类A一定是类B的友元,要看在类中是否有相应的声明。 (3) 友元关系不具有传递性。若类B是类A的友元,类C是B的友元,类C一定是类A的友元,同样要看...

    序言

    这章主要是讲解C++中友元,其中友元包括友元函数与友元类。它的主要作用是可以访问类中已隐藏或者封闭的私有或者保护的数据成员或者函数。
    关于友元其特性:

    (1) 友元关系不能被继承。
    (2) 友元关系是单向的,不具有交换性。若类B是类A的友元,类A不一定是类B的友元,要看在类中是否有相应的声明。
    (3) 友元关系不具有传递性。若类B是类A的友元,类C是B的友元,类C不一定是类A的友元,同样要看类中是否有相应的申明

    友元函数

    1. 友元函数是独立于类的外部函数
    #include <QString>
    #include <QDebug>
    
    class Girl
    {
    public:
        Girl(QString name, int age);
        friend void showInfo(Girl&);
    private:
        QString m_name;
        int m_age;
    };
    
    void showInfo(Girl &girl);
    
    #include "girl.h"
    
    Girl::Girl(QString name, int age)
    {
        m_name = name;
        m_age = age;
    }
    
    void showInfo(Girl &girl)
    {
        qDebug() << " name = " << girl.m_name << " age = " << girl.m_age;
    }
    

    结果:

    展开全文
  • 6.3、友元

    2020-06-02 17:02:58
    友元—可用于访问类中的私有的 在使用类时,主要特点之一是实现...friend关键字只出现在声明处其他类、类成员函数、全局函数都可声明为友元友元类、友元成员函数、友元函数):声明友元只需要在要声明的内容前加frien
  • 友元函数

    2021-04-10 16:51:29
    友元函数可以在放弃私有成员数据安全的条件下访问一个类中的信息。 友元函数既可以是属于任何类的非成员函数,也可以是另一个类的成员函数。友元函数不是当前类的成员函数,但它可以访问该类所有的成员。 在类...
  • c++友元函数一些见解 1、为什么要引入友元函数:在实现类之间数据共享时,减少系统开销,... 缺点:友元函数破环了封装机制,尽量使用成员函数,除非不得已的情况下才使用友元函数。 2、什么时候使用友元函数: ...
  • [C++] 友元

    2019-01-07 14:00:58
    友元是一种定义在类外部的普通函数或类,但它需要在类体内进行说明,为了与该类的成员函数加以区别,在说明时前面加以关键字friend。友元不是成员函数,但是它可以访问类中的私有成员。(百度百科) 一、友元函数 ...
  • 有些情况下,允许特定的非成员函数访问一个类的私有...友元的声明以frend开始,它只能出现在类定义的内部,友元声明可以出现在类中的任何地方:友元不是授予友元关系的那个类的成员,所有它们受其声明出现部分的访
  • 友元函数与友元

    2012-02-28 09:19:09
    友元函数和友元类的需要:  类具有封装和信息隐藏的特性。只有类的成员函数才能访问类的私有成员,程序中的其他函数是无法访问私有成员的。非成员函数可以访问类中的公有成员,但是如果将数据成员都定义为公有的,...
  • 友元

    2019-08-19 15:52:14
    (2) 友元关系是单向的,不具有交换性。若类B是类A的友元,类A一定是类B的友元,要看在类中是否有相应的声明。 (3) 友元关系不具有传递性。若类B是类A的友元,类C是B的友元,类C一定是类A的友元,同样要看类中...
  • C++友元函数和友元类用法详解

    万次阅读 多人点赞 2018-01-21 21:12:37
    在C++中,我们使用类对数据进行了隐藏和封装,类的数据成员一般都定义为私有成员,成员函数一般都定义为公有的,...友元的作用是提高了程序的运行效率(即减少了类型检查和安全检查等都需要时间开销),但它破坏了类
  • C++ 友元

    2020-01-08 11:20:41
    友元一般存在于不同类之间,在一个类中,可以用全局函数作友元函数。而在不同类中,类成员函数作友元函数 友元可以是一个函数,该函数被称为友元函数,函数既可以是全局也可以是类的成员;友元也可以是一个类,该类...
  • 有些情况下,允许特定的非成员函数访问一个类的私有成员...友元的声明以friend开始,它只能出现在类定义的内部,友元声明可以出现在类中的任何地方:友元不是授予友元关系的那个类的成员,所以它们受其声明出现...
  • C++友元函数与友元

    2020-04-01 12:50:27
    友元函数和类一种朋友关系,它属于类,但可以访问类的私有成员,它和类是一种朋友关系,也需要用类的对象去驱动,例如下面的代码: #include <iostream> using namespace std; class ASD{ friend int...
  • C++友元函数和友元

    千次阅读 2020-10-28 21:00:34
    友元为什么要友元?怎么用友元友元函数友元友元类的指针问题个人感想 为什么要友元? 为了偷懒,程序员可以少写一点代码,并且函数调用频繁的话还可以减少时间开销 怎么用友元友元函数 在类申明里面,给函数...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,069
精华内容 1,627
关键字:

友元关系不具有交换性