精华内容
下载资源
问答
  • C++之中的友元函数的作用# 友元提供了不同类的成员函数之间、类的成员函数与一般函数之间进行数据共享的机制。通过友元,一个不同函数或另一个类中的成员函数可以访问类中的私有成员和保护成员。c++中的友元为封装...

    C++之中的友元函数的作用#

    友元提供了不同类的成员函数之间、类的成员函数与一般函数之间进行数据共享的机制。通过友元,一个不同函数或另一个类中的成员函数可以访问类中的私有成员和保护成员。c++中的友元为封装隐藏这堵不透明的墙开了一个小孔,外界可以通过这个小孔窥视内部的秘密。

    友元的正确使用能提高程序的运行效率,但同时也破坏了类的封装性和数据的隐藏性,导致程序可维护性变差。
    友元函数 :

    友元函数是可以直接访问类的私有成员的非成员函数。它是定义在类外的普通函数,它不属于任何类,但需要在类的定义中加以声明,声明时只需在友元的名称前加上关键字friend,其格式如下:
    friend 类型 函数名(形式参数);
    友元函数的声明可以放在类的私有部分,也可以放在公有部分,它们是没有区别的,都说明是该类的一个友元函数。
    一个函数可以是多个类的友元函数,只需要在各个类中分别声明。
    友元函数的调用与一般函数的调用方式和原理一致。

    转载部分:

    1、为什么要引入友元函数:在实现类之间数据共享时,减少系统开销,提高效率
    具体来说:为了使其他类的成员函数直接访问该类的私有变量

    即:允许外面的类或函数去访问类的私有变量和保护变量,从而使两个类共享同一函数

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

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

    2、什么时候使用友元函数:
    1)运算符重载的某些场合需要使用友元。

    2)两个类要共享数据的时候

    3、怎么使用友元函数:

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

    1、 要访问非static成员时,需要对象做参数;–常用(友元函数常含有参数)

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

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

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

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


    本文来自 AndrewYZWang 的CSDN 博客 ,全文地址请点击:https://blog.csdn.net/andrewgithub/article/details/78760381?utm_source=copy

    本文来自 AndrewYZWang 的CSDN 博客 ,全文地址请点击:https://blog.csdn.net/andrewgithub/article/details/78760381?utm_source=copy

    展开全文
  • 90.友元函数的作用

    2018-03-18 11:56:00
    1 #include <iostream> 2 #include <cstdlib> 3 using namespace ... 5 //友元函数的主要作用就是访问私有变量 6 class myclass 7 { 8 private: 9 int x; 10 int y; 11 12 public: 1...
     1 #include <iostream>
     2 #include <cstdlib>
     3 using namespace std;
     4 
     5 //友元函数的主要作用就是访问私有变量
     6 class myclass
     7 {
     8 private:
     9     int x;
    10     int y;
    11 
    12 public:
    13     myclass(int a,int b)
    14     {
    15         x = a;
    16         y = b;
    17     }
    18     //声明是朋友可以访问私有变量
    19     friend void show(const myclass &my);
    20 };
    21 
    22 void show(const myclass &my)
    23 {
    24     cout << my.x << my.y << endl; 
    25 }
    26 
    27 void main()
    28 {
    29     myclass my1(3,4);
    30 
    31     show(my1);
    32 
    33     cin.get();
    34 }

     

    转载于:https://www.cnblogs.com/xiaochi/p/8594869.html

    展开全文
  • 友元的声明默认为了extern,就是说友元类或者友元函数的作用域已经扩展到了包含该类定义的作用域,所以即便我们在类的内部定义友元函数也是没有关系的。2、普通的非成员函数友元这类友元函数通常是操作符,例如输入...

    C++中的友元机制允许类的非公有成员被一个类或者函数访问,友元按类型分为三种:

    普通非类成员函数作为友元、类的成员函数作为友元、类作为友元。

    1、友元的内容

    友元包括友元的声明以及友元的定义。友元的声明默认为了extern,就是说友元类或者友元函数的作用域已经扩展到了包含该类定义的作用域,所以即便我们在类的内部定义友元函数也是没有关系的。

    2、普通的非成员函数友元

    这类友元函数通常是操作符,例如输入输出操作符.示例如下所示:

    //OpeClass.h

    #pragma once

    class OpeClass

    {

    friend int func(const OpeClass xx);

    public:

    OpeClass(void);

    OpeClass(int x,int y);

    ~OpeClass(void);

    private:

    int width;

    int height;

    };

    //OpeClass.cpp

    #include "OpeClass.h"

    OpeClass::OpeClass(void)

    {

    width = 50;

    height = 50;

    }

    OpeClass::OpeClass(int x,int y):width(x),height(y)

    {

    }

    OpeClass::~OpeClass(void)

    {

    }

    int func(const OpeClass xx)

    {

    return xx.height * xx.width;

    }

    //main.cpp

    #include "OpeClass.h"

    #include

    using namespace std;

    void main()

    {

    OpeClass XO;

    cout<

    system("pause");

    }

    3、类作为友元

    类作为友元需要注意的是友元类和原始类之间的相互依赖关系,如果在友元类中定义的函数使用到了原始类的私有变量,那么就需要在友元类定义的文件中包含原始类定义的头文件。

    但是在原始类的定义中(包含友元类声明的那个类),就不需要包含友元类的头文件,也不需要在类定义前去声明友元类,因为友元类的声明自身就是一种声明(它指明可以在类外找到友元类),示例程序如下所示:

    //A.h

    #pragma once

    #include

    using namespace std;

    class A

    {

    friend class B;

    public:

    ~A(void);

    static void func()

    {

    cout<

    }

    private:

    A(){};

    static const A Test;

    };

    //A.cpp

    #include "A.h"

    const A A::Test = A();

    A::~A(void)

    {

    }

    //B.h

    #pragma once

    #include "C.h"

    class B

    {

    public:

    B(void);

    ~B(void);

    void func(C& c);

    };

    //B.cpp

    #include "B.h"

    #include "A.h"

    #include "C.h"

    #include

    using namespace std;

    B::B(void)

    {

    }

    B::~B(void)

    {

    }

    void B::func(C& c)

    {

    cout<

    A::Test.func();

    c.func(A::Test);

    }

    //C.h

    #pragma once

    class A;

    class C

    {

    public:

    C(void);

    ~C(void);

    void func(const A& a);

    };

    //C.cpp

    #include "C.h"

    #include

    using namespace std;

    C::C(void)

    {

    }

    C::~C(void)

    {

    }

    void C::func(const A& a)

    {

    cout<

    }

    //main.cpp

    #include "A.h"

    #include "B.h"

    #include "C.h"

    #include

    using namespace std;

    void main()

    {

    B b;

    C c;

    b.func(c);

    system("pause");

    }

    4、类成员函数作为友元函数

    这个稍微有点复杂,因为你要类成员函数作为友元,你在声明友元的时候要用类限定符,所以必须先定义包含友元函数的类,但是在定义友元的函数时候,又必须事先定义原始类。通常的做法先定义包含友元函数的类,再定义原始类,这个顺序不能乱。(如果是友元类,则没有这种这种必须)如下面所示:

    //B.h

    #pragma once

    class A;

    class B

    {

    public:

    B(void);

    ~B(void);

    int func(A xx);

    };

    //A.h

    #pragma once

    #include "B.h"

    class A

    {

    friend int B::func(A xx);

    public:

    A(void):mx(20),my(30){}

    ~A(void){}

    private:

    int mx;

    int my;

    };

    //B.cpp

    #include "B.h"

    #include "A.h"

    B::B(void)

    {

    }

    B::~B(void)

    {

    }

    int B::func(A xx)

    {

    return xx.mx * xx.my;

    }

    //main.cpp

    #include "A.h"

    #include "B.h"

    #include

    using namespace std;

    void main()

    {

    A a;

    B b;

    cout<

    system("pause");

    }

    5、友元不具有相互性,只具有单项性

    若类B是类A的友元,类A不一定是类B的友元,要看在类中是否有相应的声明。

    6、友元不能被继承

    B是A的友元类,C是B的子类,推不出C是A的友元

    7、友元不具有传递性

    B是A的友元,C是B的友元,推不出C是A的友元

    8、相互为友元的类

    这个其实没什么好注意的,下面是实例,类A,类B互为友元

    //A.h

    #pragma once

    class A

    {

    friend class B;

    public:

    A(void);

    ~A(void);

    int funa(B& b);

    private:

    int mx;

    int my;

    };

    //A.cpp

    #include "A.h"

    #include "B.h"

    A::A(void)

    {

    mx = 10;

    my = 10;

    }

    A::~A(void)

    {

    }

    int A::funa(B& b)

    {

    return b.mb * b.mc;

    }

    //B.h

    #pragma once

    class B

    {

    friend class A;

    public:

    B(void);

    ~B(void);

    int funb(A& a);

    private:

    int mb;

    int mc;

    };

    //B.cpp

    #include "B.h"

    #include "A.h"

    B::B(void)

    {

    mb = 20;

    mc = 20;

    }

    B::~B(void)

    {

    }

    int B::funb(A& a)

    {

    return a.mx *a.my;

    }

    //main.cpp

    #include "A.h"

    #include "B.h"

    #include

    using namespace std;

    void main()

    {

    A a;

    B b;

    cout<

    cout<

    system("pause");

    }

    9、如果想要指定两个类都有成员函数作为对方的友元,那么必须第2个类是第一个类的友元

    //A.h

    #pragma once

    // class B is a friend class of A

    class A

    {

    friend class B;

    public:

    A(void):ma(10),mb(20){}

    ~A(void){}

    int funa(B& b);

    private:

    int ma;

    int mb;

    };

    //B.h

    #pragma once

    #include "A.h"

    // A's function funa is a friend function of B

    class B

    {

    friend int A::funa(B& b);

    public:

    B(void);

    ~B(void);

    int funb(A& a);

    int func(A& a);

    private:

    int mx;

    int my;

    };

    //A.cpp

    #include "A.h"

    #include "B.h"

    int A::funa(B& b)

    {

    return b.mx * b.my;

    }

    //B.cpp

    #include "B.h"

    B::B(void):mx(12),my(15)

    {

    }

    B::~B(void)

    {

    }

    int B::funb(A& a)

    {

    return a.ma + a.mb;

    }

    int B::func(A& a)

    {

    return a.ma * a.mb;

    }

    //main.cpp

    #include "A.h"

    #include "B.h"

    #include

    using namespace std;

    void main()

    {

    A a;

    B b;

    cout<

    cout<

    cout<

    }

    展开全文
  • 友元函数的作用就是为了访问类的私有数据,而成员函数可以直接访问) 类的成员函数属于类,调用时其内部数据会通过this指针进行调用 友元函数不具备this指针 友元函数可以直接访问类的私有成员,它是定义在类外部...

    友元函数

    • 有关友元函数和成员函数的区别:
      友元函数相当于全局函数,可以被本类和友元类对象调用
      友元函数和类的成员函数都可以访问类的私有成员变量或者是成员函数
      (友元函数的作用就是为了访问类的私有数据,而成员函数可以直接访问)
      类的成员函数属于类,调用时其内部数据会通过this指针进行调用
      友元函数不具备this指针
    • 友元函数可以直接访问类的私有成员,它是定义在类外部的普通函数,不属于任何类,
    • 但是需要在类的内部声明,声明时候需要加friend关键字
      需注意
      1、友元函数可以访问类的私有和保护成员,但不是类的成员函数
      2、友元函数不能用const修饰
      3、友元函数可以在类定义的任何地方声明,不受类访问限定符限制
      4、一个函数可以是多个类的友元函数
      5、友元函数的调用与普通函数的调用和原理相同
    class A
    {
    public:
    	void print()
    	{
    		cout << a << endl;
    		cout << b._b << endl;
    		cout << p << endl;
    	}
    private:
    	//非静态成员变量,可以在成员声明时给缺省值
    	int a = 10;
    	B b = 20;
    	int* p = (int*)malloc(4);
    	static int n;
    };
    
    int A::n = 10;
    
    int main()
    {
    	A a;
    	a.print();
    
    	return 0;
    }
    
    class Date;  //前置声明
    class Time
    {
    	friend class Date;//声明日期类为时间类的友元类,则在日期类中就直接访问Time类中的私有成员变量
    public:
    	Time(int hour,int minute,int second)
    		:_hour(hour)
    		, _minute(minute)
    		, _second(second)
    	{}
    private:
    	int _hour;
    	int _minute;
    	int _second;
    };
    

    友元类

    友元类的所有成员函数都可以是另一个类的友元函数,都可以访问另一个类中的非公有成员

    • 友元是单向的,不具有交换性
      比如Time类和Date类,在Time类中声明Date类为其友元类,那么可以再Date类
      中直接访问Time类的私有成员变量,但想在Time类中访问Date类中私有的成员变量则不行
    • 友元关系不能传递
      如果B是A的友元,C是B的友元,则不能说明C是A的友元
    class Date
    {
    public:
    	Date(int year = 1900, int month = 1, int day = 1)
    		:_year(year)
    		, _month(month)
    		, _day(day)
    	{}
    	void SetTimeOfDate(int hour, int minute, int second)
    	{
    		//直接访问时间类的私有的成员变量
    		_t._hour = hour;
    		_t._minute = minute;
    		_t._second = second;
    	}
    
    private:
    	int _year;
    	int _month;
    	int _day;
    	Time _t;
    };
    
    展开全文
  • 友元函数

    2020-10-07 21:14:02
    友元函数的作用:提供直接访问对象的私有成员的接口。通过友元,一个不同函数或另一个类中的成员函数可以访问类中的私有成员和保护成员。 友元函数可以访问对象的私有成员,保护成员,但是普通函数不行 友元函数...
  • C++ 友元函数与友元类

    2020-04-10 13:42:29
    C++ 友元函数与友元类一、友元函数1、声明2、友元函数的作用3、在类中声明友元函数的方式4、友元函数的注意事项二、友元类1、声明2、注意事项 一、友元函数 1、声明 friend 返回类型 函数名(参数); 2、友元函数的...
  • 友元函数的使用

    千次阅读 2019-05-11 20:13:35
    一,友元函数的作用 在类外的函数是无法访问类中的 protected 和 private变量,当在类中将一个函数声明为friend函数A时, A函数就可以访问类中的所有变量。 二,友元函数的使用 1,普通成员作为类的友员函数 ...
  • 友元函数,友元类

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

    2018-02-25 23:04:48
    如果在类的声明中定义友元函数(即友元函数的声明和定义放在一处,都在类内部),则此友元函数为内联函数,即使没有使用inline关键字,且此友元函数的作用域为文件范围,而非类范围,调用此友元函数时也无需带“类名::...
  • 文章目录1.友元介绍2.友元函数3.友元函数注意事项4....友元函数在类作用域外定义,但它需要在类体中进行说明 为了与该类成员函数加以区别,定义方式是在类中用关键字friend说明该函数,格式如下: fr
  • C++ 友元类和友元函数

    2020-10-22 09:35:30
    友元函数的作用: 可以在类的外部访问类的私有属性,但是会破坏类的封装。 b. 友元函数的格式: friend 函数返回类型 函数名(参数列表)。 c. 友元函数声明的位置和类访问修饰符无关。 //对象的成员必须初始化 class ...
  • 一、友元函数 二、友元类 三、友元优缺点 一、友元函数 结合着类特性,可知:类具有封装和信息隐藏特性。只有类成员函数才能访问类私有成员,程序中其他函数是无法访问私有成员。非成员函数可以...
  • 一、友元介绍我们知道,类的成员函数可以访问同类的其他成员函数,...友元的作用在于提高程序的运行效率 友元函数注意事项:1、友元函数不是类的成员函数,在函数体中访问对象的成员,必须用对象名加运算符“.”加对
  • 一、友元函数介绍  一般情况下,非类成员函数是不能访问成员变量。但是有时候我们为了提高程序运行效率,希望外部函数能直接...友元函数在类作用域外定义,但它需要在类体中进行说明,为了与该类成员函数加以区
  • C++ 类(友元函数和友元类)

    千次阅读 2018-07-19 16:56:20
    友元函数的作用: 可以在类的外部访问类的私有属性,但是会破坏类的封装。 b. 友元函数的格式: friend 函数返回类型 函数名(参数列表)。 c. 友元函数声明的位置和类访问修饰符无关。 //对象的成员必须初始化 ...
  • 但是,有时需要定义一些函数,这些函数不是类的一部分,但又需要频繁地访问类的数据成员,这时可以将这些函数定义为该函数的友元函数。除了友元函数外,还有友元类,两者统称为友元。友元的作用是提高了程序的运行...
  • 1)友元函数的作用: 类很好的将成员函数以及成员变量进行封装,并且设置public、protected、private用于限制访问。 而友元函数用于破坏类的封装性,可以通过与类“交朋友,获得批准”,对传入全局函数中的对象的...
  • 友元,顾名思义,是某个类“朋友”。这个朋友角色特殊之处在于它可以访问类中所有成员,包括私有、保护和...2.友元函数 3.友元成员函数 友元声明 友元使用情况具有特殊性,所以所有友元关系都是单方面
  • C++ friend友元函数、友元类详解及完整例程 ...**友元的声明默认为了extern,意味着友元类或者友元函数的作用域已经扩展到了包含该类定义的作用域,所以即便我们在类的内部定义友元函数也是没有关系的。...
  • 友元函数和友元类需要:类具有封装和信息隐藏特性。只有类成员函数才能访问类私有成员,程序中其他函数是无法访问私有成员。非成员函数可以访问类中公有成员,但是如果将数据成员都定义为公有,这又...
  • C++的友元函数

    2018-12-24 14:19:00
    友元的作用在于提高程序的运行效率,但是,它破坏了类的封装性和隐藏性,使得非成员函数可以访问类的私有成员。 友元函数没有this指针,在访问非static或非全局成员时需要对象作为参数。同时友元函数不能继承,就像...

空空如也

空空如也

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

友元函数的作用